Update vendoring for client_golang and friends (#1076)

Signed-off-by: beorn7 <beorn@soundcloud.com>

23 files changed, 965 insertions, 335 deletions

diff --git a/collector/fixtures/e2e-64k-page-output.txt b/collector/fixtures/e2e-64k-page-output.txt
index 3e7f67a..edfb373 100644
--- a/collector/fixtures/e2e-64k-page-output.txt
+++ b/collector/fixtures/e2e-64k-page-output.txt
@@ -3300,6 +3300,8 @@ node_zfs_zpool_wupdate{zpool="poolz1"} 1.10734831833266e+14
 # TYPE process_start_time_seconds gauge
 # HELP process_virtual_memory_bytes Virtual memory size in bytes.
 # TYPE process_virtual_memory_bytes gauge
+# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.
+# TYPE process_virtual_memory_max_bytes gauge
 # HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.
 # TYPE promhttp_metric_handler_requests_in_flight gauge
 promhttp_metric_handler_requests_in_flight 1
diff --git a/collector/fixtures/e2e-output.txt b/collector/fixtures/e2e-output.txt
index b3a236b..9e24ada 100644
--- a/collector/fixtures/e2e-output.txt
+++ b/collector/fixtures/e2e-output.txt
@@ -3300,6 +3300,8 @@ node_zfs_zpool_wupdate{zpool="poolz1"} 1.10734831833266e+14
 # TYPE process_start_time_seconds gauge
 # HELP process_virtual_memory_bytes Virtual memory size in bytes.
 # TYPE process_virtual_memory_bytes gauge
+# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.
+# TYPE process_virtual_memory_max_bytes gauge
 # HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.
 # TYPE promhttp_metric_handler_requests_in_flight gauge
 promhttp_metric_handler_requests_in_flight 1
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/collector.go b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
index 623d3d8..08491be 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
@@ -29,27 +29,71 @@ type Collector interface {
         // collected by this Collector to the provided channel and returns once
         // the last descriptor has been sent. The sent descriptors fulfill the
         // consistency and uniqueness requirements described in the Desc
-        // documentation. (It is valid if one and the same Collector sends
-        // duplicate descriptors. Those duplicates are simply ignored. However,
-        // two different Collectors must not send duplicate descriptors.) This
-        // method idempotently sends the same descriptors throughout the
-        // lifetime of the Collector. If a Collector encounters an error while
-        // executing this method, it must send an invalid descriptor (created
-        // with NewInvalidDesc) to signal the error to the registry.
+        // documentation.
+        //
+        // It is valid if one and the same Collector sends duplicate
+        // descriptors. Those duplicates are simply ignored. However, two
+        // different Collectors must not send duplicate descriptors.
+        //
+        // Sending no descriptor at all marks the Collector as “unchecked”,
+        // i.e. no checks will be performed at registration time, and the
+        // Collector may yield any Metric it sees fit in its Collect method.
+        //
+        // This method idempotently sends the same descriptors throughout the
+        // lifetime of the Collector.
+        //
+        // If a Collector encounters an error while executing this method, it
+        // must send an invalid descriptor (created with NewInvalidDesc) to
+        // signal the error to the registry.
         Describe(chan<- *Desc)
         // Collect is called by the Prometheus registry when collecting
         // metrics. The implementation sends each collected metric via the
         // provided channel and returns once the last metric has been sent. The
-        // descriptor of each sent metric is one of those returned by
-        // Describe. Returned metrics that share the same descriptor must differ
-        // in their variable label values. This method may be called
-        // concurrently and must therefore be implemented in a concurrency safe
-        // way. Blocking occurs at the expense of total performance of rendering
-        // all registered metrics. Ideally, Collector implementations support
-        // concurrent readers.
+        // descriptor of each sent metric is one of those returned by Describe
+        // (unless the Collector is unchecked, see above). Returned metrics that
+        // share the same descriptor must differ in their variable label
+        // values.
+        //
+        // This method may be called concurrently and must therefore be
+        // implemented in a concurrency safe way. Blocking occurs at the expense
+        // of total performance of rendering all registered metrics. Ideally,
+        // Collector implementations support concurrent readers.
         Collect(chan<- Metric)
 }
 
+// DescribeByCollect is a helper to implement the Describe method of a custom
+// Collector. It collects the metrics from the provided Collector and sends
+// their descriptors to the provided channel.
+//
+// If a Collector collects the same metrics throughout its lifetime, its
+// Describe method can simply be implemented as:
+//
+//   func (c customCollector) Describe(ch chan<- *Desc) {
+//      DescribeByCollect(c, ch)
+//   }
+//
+// However, this will not work if the metrics collected change dynamically over
+// the lifetime of the Collector in a way that their combined set of descriptors
+// changes as well. The shortcut implementation will then violate the contract
+// of the Describe method. If a Collector sometimes collects no metrics at all
+// (for example vectors like CounterVec, GaugeVec, etc., which only collect
+// metrics after a metric with a fully specified label set has been accessed),
+// it might even get registered as an unchecked Collecter (cf. the Register
+// method of the Registerer interface). Hence, only use this shortcut
+// implementation of Describe if you are certain to fulfill the contract.
+//
+// The Collector example demonstrates a use of DescribeByCollect.
+func DescribeByCollect(c Collector, descs chan<- *Desc) {
+        metrics := make(chan Metric)
+        go func() {
+                c.Collect(metrics)
+                close(metrics)
+        }()
+        for m := range metrics {
+                descs <- m.Desc()
+        }
+}
+
 // selfCollector implements Collector for a single Metric so that the Metric
 // collects itself. Add it as an anonymous field to a struct that implements
 // Metric, and call init with the Metric itself as an argument.
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/desc.go b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
index 4a755b0..7b8827f 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/desc.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
@@ -67,7 +67,7 @@ type Desc struct {
 
 // NewDesc allocates and initializes a new Desc. Errors are recorded in the Desc
 // and will be reported on registration time. variableLabels and constLabels can
-// be nil if no such labels should be set. fqName and help must not be empty.
+// be nil if no such labels should be set. fqName must not be empty.
 //
 // variableLabels only contain the label names. Their label values are variable
 // and therefore not part of the Desc. (They are managed within the Metric.)
@@ -80,10 +80,6 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
                 help:           help,
                 variableLabels: variableLabels,
         }
-        if help == "" {
-                d.err = errors.New("empty help string")
-                return d
-        }
         if !model.IsValidMetricName(model.LabelValue(fqName)) {
                 d.err = fmt.Errorf("%q is not a valid metric name", fqName)
                 return d
@@ -156,7 +152,7 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
                         Value: proto.String(v),
                 })
         }
-        sort.Sort(LabelPairSorter(d.constLabelPairs))
+        sort.Sort(labelPairSorter(d.constLabelPairs))
         return d
 }
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/doc.go b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
index 83c3657..5d9525d 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/doc.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
@@ -121,7 +121,17 @@
 // NewConstSummary (and their respective Must… versions). That will happen in
 // the Collect method. The Describe method has to return separate Desc
 // instances, representative of the “throw-away” metrics to be created later.
-// NewDesc comes in handy to create those Desc instances.
+// NewDesc comes in handy to create those Desc instances. Alternatively, you
+// could return no Desc at all, which will marke the Collector “unchecked”.  No
+// checks are porformed at registration time, but metric consistency will still
+// be ensured at scrape time, i.e. any inconsistencies will lead to scrape
+// errors. Thus, with unchecked Collectors, the responsibility to not collect
+// metrics that lead to inconsistencies in the total scrape result lies with the
+// implementer of the Collector. While this is not a desirable state, it is
+// sometimes necessary. The typical use case is a situatios where the exact
+// metrics to be returned by a Collector cannot be predicted at registration
+// time, but the implementer has sufficient knowledge of the whole system to
+// guarantee metric consistency.
 //
 // The Collector example illustrates the use case. You can also look at the
 // source code of the processCollector (mirroring process metrics), the
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/fnv.go b/vendor/github.com/prometheus/client_golang/prometheus/fnv.go
index e3b67df..3d383a7 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/fnv.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/fnv.go
@@ -1,3 +1,16 @@
+// Copyright 2018 The Prometheus Authors
+// Licensed 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 prometheus
 
 // Inline and byte-free variant of hash/fnv's fnv64a.
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go b/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
index 096454a..ba3b933 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
@@ -1,3 +1,16 @@
+// Copyright 2018 The Prometheus Authors
+// Licensed 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 prometheus
 
 import (
@@ -17,8 +30,12 @@ type goCollector struct {
         metrics memStatsMetrics
 }
 
-// NewGoCollector returns a collector which exports metrics about the current
-// go process.
+// NewGoCollector returns a collector which exports metrics about the current Go
+// process. This includes memory stats. To collect those, runtime.ReadMemStats
+// is called. This causes a stop-the-world, which is very short with Go1.9+
+// (~25µs). However, with older Go versions, the stop-the-world duration depends
+// on the heap size and can be quite significant (~1.7 ms/GiB as per
+// https://go-review.googlesource.com/c/go/+/34937).
 func NewGoCollector() Collector {
         return &goCollector{
                 goroutinesDesc: NewDesc(
@@ -265,7 +282,7 @@ func (c *goCollector) Collect(ch chan<- Metric) {
                 quantiles[float64(idx+1)/float64(len(stats.PauseQuantiles)-1)] = pq.Seconds()
         }
         quantiles[0.0] = stats.PauseQuantiles[0].Seconds()
-        ch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), float64(stats.PauseTotal.Seconds()), quantiles)
+        ch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), stats.PauseTotal.Seconds(), quantiles)
 
         ch <- MustNewConstMetric(c.goInfoDesc, GaugeValue, 1)
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
index 331783a..29dc8e3 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
@@ -16,7 +16,9 @@ package prometheus
 import (
         "fmt"
         "math"
+        "runtime"
         "sort"
+        "sync"
         "sync/atomic"
 
         "github.com/golang/protobuf/proto"
@@ -108,8 +110,9 @@ func ExponentialBuckets(start, factor float64, count int) []float64 {
 }
 
 // HistogramOpts bundles the options for creating a Histogram metric. It is
-// mandatory to set Name and Help to a non-empty string. All other fields are
-// optional and can safely be left at their zero value.
+// mandatory to set Name to a non-empty string. All other fields are optional
+// and can safely be left at their zero value, although it is strongly
+// encouraged to set a Help string.
 type HistogramOpts struct {
         // Namespace, Subsystem, and Name are components of the fully-qualified
         // name of the Histogram (created by joining these components with
@@ -120,7 +123,7 @@ type HistogramOpts struct {
         Subsystem string
         Name      string
 
-        // Help provides information about this Histogram. Mandatory!
+        // Help provides information about this Histogram.
         //
         // Metrics with the same fully-qualified name must have the same Help
         // string.
@@ -200,28 +203,49 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr
                         }
                 }
         }
-        // Finally we know the final length of h.upperBounds and can make counts.
-        h.counts = make([]uint64, len(h.upperBounds))
+        // Finally we know the final length of h.upperBounds and can make counts
+        // for both states:
+        h.counts[0].buckets = make([]uint64, len(h.upperBounds))
+        h.counts[1].buckets = make([]uint64, len(h.upperBounds))
 
         h.init(h) // Init self-collection.
         return h
 }
 
-type histogram struct {
+type histogramCounts struct {
         // sumBits contains the bits of the float64 representing the sum of all
         // observations. sumBits and count have to go first in the struct to
         // guarantee alignment for atomic operations.
         // http://golang.org/pkg/sync/atomic/#pkg-note-BUG
         sumBits uint64
         count   uint64
+        buckets []uint64
+}
 
+type histogram struct {
         selfCollector
-        // Note that there is no mutex required.
-
-        desc *Desc
+        desc     *Desc
+        writeMtx sync.Mutex // Only used in the Write method.
 
         upperBounds []float64
-        counts      []uint64
+
+        // Two counts, one is "hot" for lock-free observations, the other is
+        // "cold" for writing out a dto.Metric.
+        counts [2]histogramCounts
+
+        hotIdx int // Index of currently-hot counts. Only used within Write.
+
+        // This is a complicated one. For lock-free yet atomic observations, we
+        // need to save the total count of observations again, combined with the
+        // index of the currently-hot counts struct, so that we can perform the
+        // operation on both values atomically. The least significant bit
+        // defines the hot counts struct. The remaining 63 bits represent the
+        // total count of observations. This happens under the assumption that
+        // the 63bit count will never overflow. Rationale: An observations takes
+        // about 30ns. Let's assume it could happen in 10ns. Overflowing the
+        // counter will then take at least (2^63)*10ns, which is about 3000
+        // years.
+        countAndHotIdx uint64
 
         labelPairs []*dto.LabelPair
 }
@@ -241,36 +265,113 @@ func (h *histogram) Observe(v float64) {
         // 100 buckets: 78.1 ns/op linear - binary 54.9 ns/op
         // 300 buckets: 154 ns/op linear - binary 61.6 ns/op
         i := sort.SearchFloat64s(h.upperBounds, v)
-        if i < len(h.counts) {
-                atomic.AddUint64(&h.counts[i], 1)
+
+        // We increment h.countAndHotIdx by 2 so that the counter in the upper
+        // 63 bits gets incremented by 1. At the same time, we get the new value
+        // back, which we can use to find the currently-hot counts.
+        n := atomic.AddUint64(&h.countAndHotIdx, 2)
+        hotCounts := &h.counts[n%2]
+
+        if i < len(h.upperBounds) {
+                atomic.AddUint64(&hotCounts.buckets[i], 1)
         }
-        atomic.AddUint64(&h.count, 1)
         for {
-                oldBits := atomic.LoadUint64(&h.sumBits)
+                oldBits := atomic.LoadUint64(&hotCounts.sumBits)
                 newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
-                if atomic.CompareAndSwapUint64(&h.sumBits, oldBits, newBits) {
+                if atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {
                         break
                 }
         }
+        // Increment count last as we take it as a signal that the observation
+        // is complete.
+        atomic.AddUint64(&hotCounts.count, 1)
 }
 
 func (h *histogram) Write(out *dto.Metric) error {
-        his := &dto.Histogram{}
-        buckets := make([]*dto.Bucket, len(h.upperBounds))
+        var (
+                his                   = &dto.Histogram{}
+                buckets               = make([]*dto.Bucket, len(h.upperBounds))
+                hotCounts, coldCounts *histogramCounts
+                count                 uint64
+        )
+
+        // For simplicity, we mutex the rest of this method. It is not in the
+        // hot path, i.e.  Observe is called much more often than Write. The
+        // complication of making Write lock-free isn't worth it.
+        h.writeMtx.Lock()
+        defer h.writeMtx.Unlock()
+
+        // This is a bit arcane, which is why the following spells out this if
+        // clause in English:
+        //
+        // If the currently-hot counts struct is #0, we atomically increment
+        // h.countAndHotIdx by 1 so that from now on Observe will use the counts
+        // struct #1. Furthermore, the atomic increment gives us the new value,
+        // which, in its most significant 63 bits, tells us the count of
+        // observations done so far up to and including currently ongoing
+        // observations still using the counts struct just changed from hot to
+        // cold. To have a normal uint64 for the count, we bitshift by 1 and
+        // save the result in count. We also set h.hotIdx to 1 for the next
+        // Write call, and we will refer to counts #1 as hotCounts and to counts
+        // #0 as coldCounts.
+        //
+        // If the currently-hot counts struct is #1, we do the corresponding
+        // things the other way round. We have to _decrement_ h.countAndHotIdx
+        // (which is a bit arcane in itself, as we have to express -1 with an
+        // unsigned int...).
+        if h.hotIdx == 0 {
+                count = atomic.AddUint64(&h.countAndHotIdx, 1) >> 1
+                h.hotIdx = 1
+                hotCounts = &h.counts[1]
+                coldCounts = &h.counts[0]
+        } else {
+                count = atomic.AddUint64(&h.countAndHotIdx, ^uint64(0)) >> 1 // Decrement.
+                h.hotIdx = 0
+                hotCounts = &h.counts[0]
+                coldCounts = &h.counts[1]
+        }
+
+        // Now we have to wait for the now-declared-cold counts to actually cool
+        // down, i.e. wait for all observations still using it to finish. That's
+        // the case once the count in the cold counts struct is the same as the
+        // one atomically retrieved from the upper 63bits of h.countAndHotIdx.
+        for {
+                if count == atomic.LoadUint64(&coldCounts.count) {
+                        break
+                }
+                runtime.Gosched() // Let observations get work done.
+        }
 
-        his.SampleSum = proto.Float64(math.Float64frombits(atomic.LoadUint64(&h.sumBits)))
-        his.SampleCount = proto.Uint64(atomic.LoadUint64(&h.count))
-        var count uint64
+        his.SampleCount = proto.Uint64(count)
+        his.SampleSum = proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits)))
+        var cumCount uint64
         for i, upperBound := range h.upperBounds {
-                count += atomic.LoadUint64(&h.counts[i])
+                cumCount += atomic.LoadUint64(&coldCounts.buckets[i])
                 buckets[i] = &dto.Bucket{
-                        CumulativeCount: proto.Uint64(count),
+                        CumulativeCount: proto.Uint64(cumCount),
                         UpperBound:      proto.Float64(upperBound),
                 }
         }
+
         his.Bucket = buckets
         out.Histogram = his
         out.Label = h.labelPairs
+
+        // Finally add all the cold counts to the new hot counts and reset the cold counts.
+        atomic.AddUint64(&hotCounts.count, count)
+        atomic.StoreUint64(&coldCounts.count, 0)
+        for {
+                oldBits := atomic.LoadUint64(&hotCounts.sumBits)
+                newBits := math.Float64bits(math.Float64frombits(oldBits) + his.GetSampleSum())
+                if atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {
+                        atomic.StoreUint64(&coldCounts.sumBits, 0)
+                        break
+                }
+        }
+        for i := range h.upperBounds {
+                atomic.AddUint64(&hotCounts.buckets[i], atomic.LoadUint64(&coldCounts.buckets[i]))
+                atomic.StoreUint64(&coldCounts.buckets[i], 0)
+        }
         return nil
 }
 
@@ -454,7 +555,7 @@ func (h *constHistogram) Write(out *dto.Metric) error {
 // bucket.
 //
 // NewConstHistogram returns an error if the length of labelValues is not
-// consistent with the variable labels in Desc.
+// consistent with the variable labels in Desc or if Desc is invalid.
 func NewConstHistogram(
         desc *Desc,
         count uint64,
@@ -462,6 +563,9 @@ func NewConstHistogram(
         buckets map[float64]uint64,
         labelValues ...string,
 ) (Metric, error) {
+        if desc.err != nil {
+                return nil, desc.err
+        }
         if err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {
                 return nil, err
         }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/http.go b/vendor/github.com/prometheus/client_golang/prometheus/http.go
index dd0f819..4b8e602 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/http.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/http.go
@@ -61,15 +61,15 @@ func giveBuf(buf *bytes.Buffer) {
 // name).
 //
 // Deprecated: Please note the issues described in the doc comment of
-// InstrumentHandler. You might want to consider using
-// promhttp.InstrumentedHandler instead.
+// InstrumentHandler. You might want to consider using promhttp.Handler instead.
 func Handler() http.Handler {
         return InstrumentHandler("prometheus", UninstrumentedHandler())
 }
 
 // UninstrumentedHandler returns an HTTP handler for the DefaultGatherer.
 //
-// Deprecated: Use promhttp.Handler instead. See there for further documentation.
+// Deprecated: Use promhttp.HandlerFor(DefaultGatherer, promhttp.HandlerOpts{})
+// instead. See there for further documentation.
 func UninstrumentedHandler() http.Handler {
         return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
                 mfs, err := DefaultGatherer.Gather()
@@ -115,7 +115,7 @@ func decorateWriter(request *http.Request, writer io.Writer) (io.Writer, string)
         header := request.Header.Get(acceptEncodingHeader)
         parts := strings.Split(header, ",")
         for _, part := range parts {
-                part := strings.TrimSpace(part)
+                part = strings.TrimSpace(part)
                 if part == "gzip" || strings.HasPrefix(part, "gzip;") {
                         return gzip.NewWriter(writer), "gzip"
                 }
@@ -139,16 +139,6 @@ var now nower = nowFunc(func() time.Time {
         return time.Now()
 })
 
-func nowSeries(t ...time.Time) nower {
-        return nowFunc(func() time.Time {
-                defer func() {
-                        t = t[1:]
-                }()
-
-                return t[0]
-        })
-}
-
 // InstrumentHandler wraps the given HTTP handler for instrumentation. It
 // registers four metric collectors (if not already done) and reports HTTP
 // metrics to the (newly or already) registered collectors: http_requests_total
@@ -159,21 +149,14 @@ func nowSeries(t ...time.Time) nower {
 // (label name "method") and HTTP status code (label name "code").
 //
 // Deprecated: InstrumentHandler has several issues. Use the tooling provided in
-// package promhttp instead. The issues are the following:
-//
-// - It uses Summaries rather than Histograms. Summaries are not useful if
-// aggregation across multiple instances is required.
-//
-// - It uses microseconds as unit, which is deprecated and should be replaced by
-// seconds.
-//
-// - The size of the request is calculated in a separate goroutine. Since this
-// calculator requires access to the request header, it creates a race with
-// any writes to the header performed during request handling.
-// httputil.ReverseProxy is a prominent example for a handler
-// performing such writes.
-//
-// - It has additional issues with HTTP/2, cf.
+// package promhttp instead. The issues are the following: (1) It uses Summaries
+// rather than Histograms. Summaries are not useful if aggregation across
+// multiple instances is required. (2) It uses microseconds as unit, which is
+// deprecated and should be replaced by seconds. (3) The size of the request is
+// calculated in a separate goroutine. Since this calculator requires access to
+// the request header, it creates a race with any writes to the header performed
+// during request handling.  httputil.ReverseProxy is a prominent example for a
+// handler performing such writes. (4) It has additional issues with HTTP/2, cf.
 // https://github.com/prometheus/client_golang/issues/272.
 func InstrumentHandler(handlerName string, handler http.Handler) http.HandlerFunc {
         return InstrumentHandlerFunc(handlerName, handler.ServeHTTP)
@@ -317,7 +300,7 @@ func InstrumentHandlerFuncWithOpts(opts SummaryOpts, handlerFunc func(http.Respo
 }
 
 func computeApproximateRequestSize(r *http.Request) <-chan int {
-        // Get URL length in current go routine for avoiding a race condition.
+        // Get URL length in current goroutine for avoiding a race condition.
         // HandlerFunc that runs in parallel may modify the URL.
         s := 0
         if r.URL != nil {
@@ -352,10 +335,9 @@ func computeApproximateRequestSize(r *http.Request) <-chan int {
 type responseWriterDelegator struct {
         http.ResponseWriter
 
-        handler, method string
-        status          int
-        written         int64
-        wroteHeader     bool
+        status      int
+        written     int64
+        wroteHeader bool
 }
 
 func (r *responseWriterDelegator) WriteHeader(code int) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/internal/metric.go b/vendor/github.com/prometheus/client_golang/prometheus/internal/metric.go
new file mode 100644
index 0000000..351c26e
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/internal/metric.go
@@ -0,0 +1,85 @@
+// Copyright 2018 The Prometheus Authors
+// Licensed 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 internal
+
+import (
+        "sort"
+
+        dto "github.com/prometheus/client_model/go"
+)
+
+// metricSorter is a sortable slice of *dto.Metric.
+type metricSorter []*dto.Metric
+
+func (s metricSorter) Len() int {
+        return len(s)
+}
+
+func (s metricSorter) Swap(i, j int) {
+        s[i], s[j] = s[j], s[i]
+}
+
+func (s metricSorter) Less(i, j int) bool {
+        if len(s[i].Label) != len(s[j].Label) {
+                // This should not happen. The metrics are
+                // inconsistent. However, we have to deal with the fact, as
+                // people might use custom collectors or metric family injection
+                // to create inconsistent metrics. So let's simply compare the
+                // number of labels in this case. That will still yield
+                // reproducible sorting.
+                return len(s[i].Label) < len(s[j].Label)
+        }
+        for n, lp := range s[i].Label {
+                vi := lp.GetValue()
+                vj := s[j].Label[n].GetValue()
+                if vi != vj {
+                        return vi < vj
+                }
+        }
+
+        // We should never arrive here. Multiple metrics with the same
+        // label set in the same scrape will lead to undefined ingestion
+        // behavior. However, as above, we have to provide stable sorting
+        // here, even for inconsistent metrics. So sort equal metrics
+        // by their timestamp, with missing timestamps (implying "now")
+        // coming last.
+        if s[i].TimestampMs == nil {
+                return false
+        }
+        if s[j].TimestampMs == nil {
+                return true
+        }
+        return s[i].GetTimestampMs() < s[j].GetTimestampMs()
+}
+
+// NormalizeMetricFamilies returns a MetricFamily slice with empty
+// MetricFamilies pruned and the remaining MetricFamilies sorted by name within
+// the slice, with the contained Metrics sorted within each MetricFamily.
+func NormalizeMetricFamilies(metricFamiliesByName map[string]*dto.MetricFamily) []*dto.MetricFamily {
+        for _, mf := range metricFamiliesByName {
+                sort.Sort(metricSorter(mf.Metric))
+        }
+        names := make([]string, 0, len(metricFamiliesByName))
+        for name, mf := range metricFamiliesByName {
+                if len(mf.Metric) > 0 {
+                        names = append(names, name)
+                }
+        }
+        sort.Strings(names)
+        result := make([]*dto.MetricFamily, 0, len(names))
+        for _, name := range names {
+                result = append(result, metricFamiliesByName[name])
+        }
+        return result
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/labels.go b/vendor/github.com/prometheus/client_golang/prometheus/labels.go
index 2502e37..e68f132 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/labels.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/labels.go
@@ -1,3 +1,16 @@
+// Copyright 2018 The Prometheus Authors
+// Licensed 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 prometheus
 
 import (
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/metric.go b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
index 6213ee8..55e6d86 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/metric.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
@@ -15,6 +15,9 @@ package prometheus
 
 import (
         "strings"
+        "time"
+
+        "github.com/golang/protobuf/proto"
 
         dto "github.com/prometheus/client_model/go"
 )
@@ -43,9 +46,8 @@ type Metric interface {
         // While populating dto.Metric, it is the responsibility of the
         // implementation to ensure validity of the Metric protobuf (like valid
         // UTF-8 strings or syntactically valid metric and label names). It is
-        // recommended to sort labels lexicographically. (Implementers may find
-        // LabelPairSorter useful for that.) Callers of Write should still make
-        // sure of sorting if they depend on it.
+        // recommended to sort labels lexicographically. Callers of Write should
+        // still make sure of sorting if they depend on it.
         Write(*dto.Metric) error
         // TODO(beorn7): The original rationale of passing in a pre-allocated
         // dto.Metric protobuf to save allocations has disappeared. The
@@ -57,8 +59,9 @@ type Metric interface {
 // implementation XXX has its own XXXOpts type, but in most cases, it is just be
 // an alias of this type (which might change when the requirement arises.)
 //
-// It is mandatory to set Name and Help to a non-empty string. All other fields
-// are optional and can safely be left at their zero value.
+// It is mandatory to set Name to a non-empty string. All other fields are
+// optional and can safely be left at their zero value, although it is strongly
+// encouraged to set a Help string.
 type Opts struct {
         // Namespace, Subsystem, and Name are components of the fully-qualified
         // name of the Metric (created by joining these components with
@@ -69,7 +72,7 @@ type Opts struct {
         Subsystem string
         Name      string
 
-        // Help provides information about this metric. Mandatory!
+        // Help provides information about this metric.
         //
         // Metrics with the same fully-qualified name must have the same Help
         // string.
@@ -110,37 +113,22 @@ func BuildFQName(namespace, subsystem, name string) string {
         return name
 }
 
-// LabelPairSorter implements sort.Interface. It is used to sort a slice of
-// dto.LabelPair pointers. This is useful for implementing the Write method of
-// custom metrics.
-type LabelPairSorter []*dto.LabelPair
+// labelPairSorter implements sort.Interface. It is used to sort a slice of
+// dto.LabelPair pointers.
+type labelPairSorter []*dto.LabelPair
 
-func (s LabelPairSorter) Len() int {
+func (s labelPairSorter) Len() int {
         return len(s)
 }
 
-func (s LabelPairSorter) Swap(i, j int) {
+func (s labelPairSorter) Swap(i, j int) {
         s[i], s[j] = s[j], s[i]
 }
 
-func (s LabelPairSorter) Less(i, j int) bool {
+func (s labelPairSorter) Less(i, j int) bool {
         return s[i].GetName() < s[j].GetName()
 }
 
-type hashSorter []uint64
-
-func (s hashSorter) Len() int {
-        return len(s)
-}
-
-func (s hashSorter) Swap(i, j int) {
-        s[i], s[j] = s[j], s[i]
-}
-
-func (s hashSorter) Less(i, j int) bool {
-        return s[i] < s[j]
-}
-
 type invalidMetric struct {
         desc *Desc
         err  error
@@ -156,3 +144,31 @@ func NewInvalidMetric(desc *Desc, err error) Metric {
 func (m *invalidMetric) Desc() *Desc { return m.desc }
 
 func (m *invalidMetric) Write(*dto.Metric) error { return m.err }
+
+type timestampedMetric struct {
+        Metric
+        t time.Time
+}
+
+func (m timestampedMetric) Write(pb *dto.Metric) error {
+        e := m.Metric.Write(pb)
+        pb.TimestampMs = proto.Int64(m.t.Unix()*1000 + int64(m.t.Nanosecond()/1000000))
+        return e
+}
+
+// NewMetricWithTimestamp returns a new Metric wrapping the provided Metric in a
+// way that it has an explicit timestamp set to the provided Time. This is only
+// useful in rare cases as the timestamp of a Prometheus metric should usually
+// be set by the Prometheus server during scraping. Exceptions include mirroring
+// metrics with given timestamps from other metric
+// sources.
+//
+// NewMetricWithTimestamp works best with MustNewConstMetric,
+// MustNewConstHistogram, and MustNewConstSummary, see example.
+//
+// Currently, the exposition formats used by Prometheus are limited to
+// millisecond resolution. Thus, the provided time will be rounded down to the
+// next full millisecond value.
+func NewMetricWithTimestamp(t time.Time, m Metric) Metric {
+        return timestampedMetric{Metric: m, t: t}
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
index 32ac74a..55176d5 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
@@ -13,46 +13,74 @@
 
 package prometheus
 
-import "github.com/prometheus/procfs"
+import (
+        "errors"
+        "os"
+
+        "github.com/prometheus/procfs"
+)
 
 type processCollector struct {
-        pid             int
         collectFn       func(chan<- Metric)
         pidFn           func() (int, error)
+        reportErrors    bool
         cpuTotal        *Desc
         openFDs, maxFDs *Desc
-        vsize, rss      *Desc
+        vsize, maxVsize *Desc
+        rss             *Desc
         startTime       *Desc
 }
 
+// ProcessCollectorOpts defines the behavior of a process metrics collector
+// created with NewProcessCollector.
+type ProcessCollectorOpts struct {
+        // PidFn returns the PID of the process the collector collects metrics
+        // for. It is called upon each collection. By default, the PID of the
+        // current process is used, as determined on construction time by
+        // calling os.Getpid().
+        PidFn func() (int, error)
+        // If non-empty, each of the collected metrics is prefixed by the
+        // provided string and an underscore ("_").
+        Namespace string
+        // If true, any error encountered during collection is reported as an
+        // invalid metric (see NewInvalidMetric). Otherwise, errors are ignored
+        // and the collected metrics will be incomplete. (Possibly, no metrics
+        // will be collected at all.) While that's usually not desired, it is
+        // appropriate for the common "mix-in" of process metrics, where process
+        // metrics are nice to have, but failing to collect them should not
+        // disrupt the collection of the remaining metrics.
+        ReportErrors bool
+}
+
 // NewProcessCollector returns a collector which exports the current state of
 // process metrics including CPU, memory and file descriptor usage as well as
-// the process start time for the given process ID under the given namespace.
+// the process start time. The detailed behavior is defined by the provided
+// ProcessCollectorOpts. The zero value of ProcessCollectorOpts creates a
+// collector for the current process with an empty namespace string and no error
+// reporting.
 //
 // Currently, the collector depends on a Linux-style proc filesystem and
 // therefore only exports metrics for Linux.
-func NewProcessCollector(pid int, namespace string) Collector {
-        return NewProcessCollectorPIDFn(
-                func() (int, error) { return pid, nil },
-                namespace,
-        )
-}
-
-// NewProcessCollectorPIDFn works like NewProcessCollector but the process ID is
-// determined on each collect anew by calling the given pidFn function.
-func NewProcessCollectorPIDFn(
-        pidFn func() (int, error),
-        namespace string,
-) Collector {
+//
+// Note: An older version of this function had the following signature:
+//
+//     NewProcessCollector(pid int, namespace string) Collector
+//
+// Most commonly, it was called as
+//
+//     NewProcessCollector(os.Getpid(), "")
+//
+// The following call of the current version is equivalent to the above:
+//
+//     NewProcessCollector(ProcessCollectorOpts{})
+func NewProcessCollector(opts ProcessCollectorOpts) Collector {
         ns := ""
-        if len(namespace) > 0 {
-                ns = namespace + "_"
+        if len(opts.Namespace) > 0 {
+                ns = opts.Namespace + "_"
         }
 
-        c := processCollector{
-                pidFn:     pidFn,
-                collectFn: func(chan<- Metric) {},
-
+        c := &processCollector{
+                reportErrors: opts.ReportErrors,
                 cpuTotal: NewDesc(
                         ns+"process_cpu_seconds_total",
                         "Total user and system CPU time spent in seconds.",
@@ -73,6 +101,11 @@ func NewProcessCollectorPIDFn(
                         "Virtual memory size in bytes.",
                         nil, nil,
                 ),
+                maxVsize: NewDesc(
+                        ns+"process_virtual_memory_max_bytes",
+                        "Maximum amount of virtual memory available in bytes.",
+                        nil, nil,
+                ),
                 rss: NewDesc(
                         ns+"process_resident_memory_bytes",
                         "Resident memory size in bytes.",
@@ -85,12 +118,23 @@ func NewProcessCollectorPIDFn(
                 ),
         }
 
+        if opts.PidFn == nil {
+                pid := os.Getpid()
+                c.pidFn = func() (int, error) { return pid, nil }
+        } else {
+                c.pidFn = opts.PidFn
+        }
+
         // Set up process metric collection if supported by the runtime.
         if _, err := procfs.NewStat(); err == nil {
                 c.collectFn = c.processCollect
+        } else {
+                c.collectFn = func(ch chan<- Metric) {
+                        c.reportError(ch, nil, errors.New("process metrics not supported on this platform"))
+                }
         }
 
-        return &c
+        return c
 }
 
 // Describe returns all descriptions of the collector.
@@ -99,6 +143,7 @@ func (c *processCollector) Describe(ch chan<- *Desc) {
         ch <- c.openFDs
         ch <- c.maxFDs
         ch <- c.vsize
+        ch <- c.maxVsize
         ch <- c.rss
         ch <- c.startTime
 }
@@ -108,16 +153,16 @@ func (c *processCollector) Collect(ch chan<- Metric) {
         c.collectFn(ch)
 }
 
-// TODO(ts): Bring back error reporting by reverting 7faf9e7 as soon as the
-// client allows users to configure the error behavior.
 func (c *processCollector) processCollect(ch chan<- Metric) {
         pid, err := c.pidFn()
         if err != nil {
+                c.reportError(ch, nil, err)
                 return
         }
 
         p, err := procfs.NewProc(pid)
         if err != nil {
+                c.reportError(ch, nil, err)
                 return
         }
 
@@ -127,14 +172,33 @@ func (c *processCollector) processCollect(ch chan<- Metric) {
                 ch <- MustNewConstMetric(c.rss, GaugeValue, float64(stat.ResidentMemory()))
                 if startTime, err := stat.StartTime(); err == nil {
                         ch <- MustNewConstMetric(c.startTime, GaugeValue, startTime)
+                } else {
+                        c.reportError(ch, c.startTime, err)
                 }
+        } else {
+                c.reportError(ch, nil, err)
         }
 
         if fds, err := p.FileDescriptorsLen(); err == nil {
                 ch <- MustNewConstMetric(c.openFDs, GaugeValue, float64(fds))
+        } else {
+                c.reportError(ch, c.openFDs, err)
         }
 
         if limits, err := p.NewLimits(); err == nil {
                 ch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(limits.OpenFiles))
+                ch <- MustNewConstMetric(c.maxVsize, GaugeValue, float64(limits.AddressSpace))
+        } else {
+                c.reportError(ch, nil, err)
+        }
+}
+
+func (c *processCollector) reportError(ch chan<- Metric, desc *Desc, err error) {
+        if !c.reportErrors {
+                return
+        }
+        if desc == nil {
+                desc = NewInvalidDesc(err)
         }
+        ch <- NewInvalidMetric(desc, err)
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go
index 9c1c66d..67b56d3 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go
@@ -76,16 +76,16 @@ type flusherDelegator struct{ *responseWriterDelegator }
 type hijackerDelegator struct{ *responseWriterDelegator }
 type readerFromDelegator struct{ *responseWriterDelegator }
 
-func (d *closeNotifierDelegator) CloseNotify() <-chan bool {
+func (d closeNotifierDelegator) CloseNotify() <-chan bool {
         return d.ResponseWriter.(http.CloseNotifier).CloseNotify()
 }
-func (d *flusherDelegator) Flush() {
+func (d flusherDelegator) Flush() {
         d.ResponseWriter.(http.Flusher).Flush()
 }
-func (d *hijackerDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+func (d hijackerDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) {
         return d.ResponseWriter.(http.Hijacker).Hijack()
 }
-func (d *readerFromDelegator) ReadFrom(re io.Reader) (int64, error) {
+func (d readerFromDelegator) ReadFrom(re io.Reader) (int64, error) {
         if !d.wroteHeader {
                 d.WriteHeader(http.StatusOK)
         }
@@ -102,34 +102,34 @@ func init() {
                 return d
         }
         pickDelegator[closeNotifier] = func(d *responseWriterDelegator) delegator { // 1
-                return &closeNotifierDelegator{d}
+                return closeNotifierDelegator{d}
         }
         pickDelegator[flusher] = func(d *responseWriterDelegator) delegator { // 2
-                return &flusherDelegator{d}
+                return flusherDelegator{d}
         }
         pickDelegator[flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 3
                 return struct {
                         *responseWriterDelegator
                         http.Flusher
                         http.CloseNotifier
-                }{d, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[hijacker] = func(d *responseWriterDelegator) delegator { // 4
-                return &hijackerDelegator{d}
+                return hijackerDelegator{d}
         }
         pickDelegator[hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 5
                 return struct {
                         *responseWriterDelegator
                         http.Hijacker
                         http.CloseNotifier
-                }{d, &hijackerDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, hijackerDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 6
                 return struct {
                         *responseWriterDelegator
                         http.Hijacker
                         http.Flusher
-                }{d, &hijackerDelegator{d}, &flusherDelegator{d}}
+                }{d, hijackerDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 7
                 return struct {
@@ -137,7 +137,7 @@ func init() {
                         http.Hijacker
                         http.Flusher
                         http.CloseNotifier
-                }{d, &hijackerDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[readerFrom] = func(d *responseWriterDelegator) delegator { // 8
                 return readerFromDelegator{d}
@@ -147,14 +147,14 @@ func init() {
                         *responseWriterDelegator
                         io.ReaderFrom
                         http.CloseNotifier
-                }{d, &readerFromDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, readerFromDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 10
                 return struct {
                         *responseWriterDelegator
                         io.ReaderFrom
                         http.Flusher
-                }{d, &readerFromDelegator{d}, &flusherDelegator{d}}
+                }{d, readerFromDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 11
                 return struct {
@@ -162,14 +162,14 @@ func init() {
                         io.ReaderFrom
                         http.Flusher
                         http.CloseNotifier
-                }{d, &readerFromDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 12
                 return struct {
                         *responseWriterDelegator
                         io.ReaderFrom
                         http.Hijacker
-                }{d, &readerFromDelegator{d}, &hijackerDelegator{d}}
+                }{d, readerFromDelegator{d}, hijackerDelegator{d}}
         }
         pickDelegator[readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 13
                 return struct {
@@ -177,7 +177,7 @@ func init() {
                         io.ReaderFrom
                         http.Hijacker
                         http.CloseNotifier
-                }{d, &readerFromDelegator{d}, &hijackerDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 14
                 return struct {
@@ -185,7 +185,7 @@ func init() {
                         io.ReaderFrom
                         http.Hijacker
                         http.Flusher
-                }{d, &readerFromDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}}
+                }{d, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 15
                 return struct {
@@ -194,6 +194,6 @@ func init() {
                         http.Hijacker
                         http.Flusher
                         http.CloseNotifier
-                }{d, &readerFromDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_1_8.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_1_8.go
index 75a905e..31a7069 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_1_8.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_1_8.go
@@ -22,27 +22,27 @@ import (
 
 type pusherDelegator struct{ *responseWriterDelegator }
 
-func (d *pusherDelegator) Push(target string, opts *http.PushOptions) error {
+func (d pusherDelegator) Push(target string, opts *http.PushOptions) error {
         return d.ResponseWriter.(http.Pusher).Push(target, opts)
 }
 
 func init() {
         pickDelegator[pusher] = func(d *responseWriterDelegator) delegator { // 16
-                return &pusherDelegator{d}
+                return pusherDelegator{d}
         }
         pickDelegator[pusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 17
                 return struct {
                         *responseWriterDelegator
                         http.Pusher
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+flusher] = func(d *responseWriterDelegator) delegator { // 18
                 return struct {
                         *responseWriterDelegator
                         http.Pusher
                         http.Flusher
-                }{d, &pusherDelegator{d}, &flusherDelegator{d}}
+                }{d, pusherDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[pusher+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 19
                 return struct {
@@ -50,14 +50,14 @@ func init() {
                         http.Pusher
                         http.Flusher
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+hijacker] = func(d *responseWriterDelegator) delegator { // 20
                 return struct {
                         *responseWriterDelegator
                         http.Pusher
                         http.Hijacker
-                }{d, &pusherDelegator{d}, &hijackerDelegator{d}}
+                }{d, pusherDelegator{d}, hijackerDelegator{d}}
         }
         pickDelegator[pusher+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 21
                 return struct {
@@ -65,7 +65,7 @@ func init() {
                         http.Pusher
                         http.Hijacker
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &hijackerDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 22
                 return struct {
@@ -73,7 +73,7 @@ func init() {
                         http.Pusher
                         http.Hijacker
                         http.Flusher
-                }{d, &pusherDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}}
+                }{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[pusher+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { //23
                 return struct {
@@ -82,14 +82,14 @@ func init() {
                         http.Hijacker
                         http.Flusher
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+readerFrom] = func(d *responseWriterDelegator) delegator { // 24
                 return struct {
                         *responseWriterDelegator
                         http.Pusher
                         io.ReaderFrom
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+closeNotifier] = func(d *responseWriterDelegator) delegator { // 25
                 return struct {
@@ -97,7 +97,7 @@ func init() {
                         http.Pusher
                         io.ReaderFrom
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 26
                 return struct {
@@ -105,7 +105,7 @@ func init() {
                         http.Pusher
                         io.ReaderFrom
                         http.Flusher
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &flusherDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 27
                 return struct {
@@ -114,7 +114,7 @@ func init() {
                         io.ReaderFrom
                         http.Flusher
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 28
                 return struct {
@@ -122,7 +122,7 @@ func init() {
                         http.Pusher
                         io.ReaderFrom
                         http.Hijacker
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &hijackerDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 29
                 return struct {
@@ -131,7 +131,7 @@ func init() {
                         io.ReaderFrom
                         http.Hijacker
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &hijackerDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 30
                 return struct {
@@ -140,7 +140,7 @@ func init() {
                         io.ReaderFrom
                         http.Hijacker
                         http.Flusher
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
         }
         pickDelegator[pusher+readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 31
                 return struct {
@@ -150,7 +150,7 @@ func init() {
                         http.Hijacker
                         http.Flusher
                         http.CloseNotifier
-                }{d, &pusherDelegator{d}, &readerFromDelegator{d}, &hijackerDelegator{d}, &flusherDelegator{d}, &closeNotifierDelegator{d}}
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
 }
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
index 8dc2603..0135737 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
@@ -302,7 +302,7 @@ func decorateWriter(request *http.Request, writer io.Writer, compressionDisabled
         header := request.Header.Get(acceptEncodingHeader)
         parts := strings.Split(header, ",")
         for _, part := range parts {
-                part := strings.TrimSpace(part)
+                part = strings.TrimSpace(part)
                 if part == "gzip" || strings.HasPrefix(part, "gzip;") {
                         return gzip.NewWriter(writer), "gzip"
                 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client_1_8.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client_1_8.go
index 0bd80c3..a034d1e 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client_1_8.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client_1_8.go
@@ -81,8 +81,8 @@ func InstrumentRoundTripperTrace(it *InstrumentTrace, next http.RoundTripper) Ro
                                 }
                         },
                         DNSDone: func(_ httptrace.DNSDoneInfo) {
-                                if it.DNSStart != nil {
-                                        it.DNSStart(time.Since(start).Seconds())
+                                if it.DNSDone != nil {
+                                        it.DNSDone(time.Since(start).Seconds())
                                 }
                         },
                         ConnectStart: func(_, _ string) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/registry.go b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
index bee3703..2c0b908 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/registry.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
@@ -15,17 +15,18 @@ package prometheus
 
 import (
         "bytes"
-        "errors"
         "fmt"
-        "os"
         "runtime"
         "sort"
+        "strings"
         "sync"
         "unicode/utf8"
 
         "github.com/golang/protobuf/proto"
 
         dto "github.com/prometheus/client_model/go"
+
+        "github.com/prometheus/client_golang/prometheus/internal"
 )
 
 const (
@@ -38,12 +39,13 @@ const (
 // Registerer and Gatherer interface a number of convenience functions in this
 // package act on. Initially, both variables point to the same Registry, which
 // has a process collector (currently on Linux only, see NewProcessCollector)
-// and a Go collector (see NewGoCollector) already registered. This approach to
-// keep default instances as global state mirrors the approach of other packages
-// in the Go standard library. Note that there are caveats. Change the variables
-// with caution and only if you understand the consequences. Users who want to
-// avoid global state altogether should not use the convenience functions and
-// act on custom instances instead.
+// and a Go collector (see NewGoCollector, in particular the note about
+// stop-the-world implication with Go versions older than 1.9) already
+// registered. This approach to keep default instances as global state mirrors
+// the approach of other packages in the Go standard library. Note that there
+// are caveats. Change the variables with caution and only if you understand the
+// consequences. Users who want to avoid global state altogether should not use
+// the convenience functions and act on custom instances instead.
 var (
         defaultRegistry              = NewRegistry()
         DefaultRegisterer Registerer = defaultRegistry
@@ -51,7 +53,7 @@ var (
 )
 
 func init() {
-        MustRegister(NewProcessCollector(os.Getpid(), ""))
+        MustRegister(NewProcessCollector(ProcessCollectorOpts{}))
         MustRegister(NewGoCollector())
 }
 
@@ -67,7 +69,8 @@ func NewRegistry() *Registry {
 
 // NewPedanticRegistry returns a registry that checks during collection if each
 // collected Metric is consistent with its reported Desc, and if the Desc has
-// actually been registered with the registry.
+// actually been registered with the registry. Unchecked Collectors (those whose
+// Describe methed does not yield any descriptors) are excluded from the check.
 //
 // Usually, a Registry will be happy as long as the union of all collected
 // Metrics is consistent and valid even if some metrics are not consistent with
@@ -97,6 +100,14 @@ type Registerer interface {
         // returned error is an instance of AlreadyRegisteredError, which
         // contains the previously registered Collector.
         //
+        // A Collector whose Describe method does not yield any Desc is treated
+        // as unchecked. Registration will always succeed. No check for
+        // re-registering (see previous paragraph) is performed. Thus, the
+        // caller is responsible for not double-registering the same unchecked
+        // Collector, and for providing a Collector that will not cause
+        // inconsistent metrics on collection. (This would lead to scrape
+        // errors.)
+        //
         // It is in general not safe to register the same Collector multiple
         // times concurrently.
         Register(Collector) error
@@ -107,7 +118,9 @@ type Registerer interface {
         // Unregister unregisters the Collector that equals the Collector passed
         // in as an argument.  (Two Collectors are considered equal if their
         // Describe method yields the same set of descriptors.) The function
-        // returns whether a Collector was unregistered.
+        // returns whether a Collector was unregistered. Note that an unchecked
+        // Collector cannot be unregistered (as its Describe method does not
+        // yield any descriptor).
         //
         // Note that even after unregistering, it will not be possible to
         // register a new Collector that is inconsistent with the unregistered
@@ -125,15 +138,23 @@ type Registerer interface {
 type Gatherer interface {
         // Gather calls the Collect method of the registered Collectors and then
         // gathers the collected metrics into a lexicographically sorted slice
-        // of MetricFamily protobufs. Even if an error occurs, Gather attempts
-        // to gather as many metrics as possible. Hence, if a non-nil error is
-        // returned, the returned MetricFamily slice could be nil (in case of a
-        // fatal error that prevented any meaningful metric collection) or
-        // contain a number of MetricFamily protobufs, some of which might be
-        // incomplete, and some might be missing altogether. The returned error
-        // (which might be a MultiError) explains the details. In scenarios
-        // where complete collection is critical, the returned MetricFamily
-        // protobufs should be disregarded if the returned error is non-nil.
+        // of uniquely named MetricFamily protobufs. Gather ensures that the
+        // returned slice is valid and self-consistent so that it can be used
+        // for valid exposition. As an exception to the strict consistency
+        // requirements described for metric.Desc, Gather will tolerate
+        // different sets of label names for metrics of the same metric family.
+        //
+        // Even if an error occurs, Gather attempts to gather as many metrics as
+        // possible. Hence, if a non-nil error is returned, the returned
+        // MetricFamily slice could be nil (in case of a fatal error that
+        // prevented any meaningful metric collection) or contain a number of
+        // MetricFamily protobufs, some of which might be incomplete, and some
+        // might be missing altogether. The returned error (which might be a
+        // MultiError) explains the details. Note that this is mostly useful for
+        // debugging purposes. If the gathered protobufs are to be used for
+        // exposition in actual monitoring, it is almost always better to not
+        // expose an incomplete result and instead disregard the returned
+        // MetricFamily protobufs in case the returned error is non-nil.
         Gather() ([]*dto.MetricFamily, error)
 }
 
@@ -234,6 +255,7 @@ type Registry struct {
         collectorsByID        map[uint64]Collector // ID is a hash of the descIDs.
         descIDs               map[uint64]struct{}
         dimHashesByName       map[string]uint64
+        uncheckedCollectors   []Collector
         pedanticChecksEnabled bool
 }
 
@@ -291,9 +313,10 @@ func (r *Registry) Register(c Collector) error {
                         }
                 }
         }
-        // Did anything happen at all?
+        // A Collector yielding no Desc at all is considered unchecked.
         if len(newDescIDs) == 0 {
-                return errors.New("collector has no descriptors")
+                r.uncheckedCollectors = append(r.uncheckedCollectors, c)
+                return nil
         }
         if existing, exists := r.collectorsByID[collectorID]; exists {
                 return AlreadyRegisteredError{
@@ -367,20 +390,24 @@ func (r *Registry) MustRegister(cs ...Collector) {
 // Gather implements Gatherer.
 func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
         var (
-                metricChan        = make(chan Metric, capMetricChan)
-                metricHashes      = map[uint64]struct{}{}
-                dimHashes         = map[string]uint64{}
-                wg                sync.WaitGroup
-                errs              MultiError          // The collected errors to return in the end.
-                registeredDescIDs map[uint64]struct{} // Only used for pedantic checks
+                checkedMetricChan   = make(chan Metric, capMetricChan)
+                uncheckedMetricChan = make(chan Metric, capMetricChan)
+                metricHashes        = map[uint64]struct{}{}
+                wg                  sync.WaitGroup
+                errs                MultiError          // The collected errors to return in the end.
+                registeredDescIDs   map[uint64]struct{} // Only used for pedantic checks
         )
 
         r.mtx.RLock()
-        goroutineBudget := len(r.collectorsByID)
+        goroutineBudget := len(r.collectorsByID) + len(r.uncheckedCollectors)
         metricFamiliesByName := make(map[string]*dto.MetricFamily, len(r.dimHashesByName))
-        collectors := make(chan Collector, len(r.collectorsByID))
+        checkedCollectors := make(chan Collector, len(r.collectorsByID))
+        uncheckedCollectors := make(chan Collector, len(r.uncheckedCollectors))
         for _, collector := range r.collectorsByID {
-                collectors <- collector
+                checkedCollectors <- collector
+        }
+        for _, collector := range r.uncheckedCollectors {
+                uncheckedCollectors <- collector
         }
         // In case pedantic checks are enabled, we have to copy the map before
         // giving up the RLock.
@@ -397,12 +424,14 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
         collectWorker := func() {
                 for {
                         select {
-                        case collector := <-collectors:
-                                collector.Collect(metricChan)
-                                wg.Done()
+                        case collector := <-checkedCollectors:
+                                collector.Collect(checkedMetricChan)
+                        case collector := <-uncheckedCollectors:
+                                collector.Collect(uncheckedMetricChan)
                         default:
                                 return
                         }
+                        wg.Done()
                 }
         }
 
@@ -410,53 +439,96 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
         go collectWorker()
         goroutineBudget--
 
-        // Close the metricChan once all collectors are collected.
+        // Close checkedMetricChan and uncheckedMetricChan once all collectors
+        // are collected.
         go func() {
                 wg.Wait()
-                close(metricChan)
+                close(checkedMetricChan)
+                close(uncheckedMetricChan)
         }()
 
-        // Drain metricChan in case of premature return.
+        // Drain checkedMetricChan and uncheckedMetricChan in case of premature return.
         defer func() {
-                for range metricChan {
+                if checkedMetricChan != nil {
+                        for range checkedMetricChan {
+                        }
+                }
+                if uncheckedMetricChan != nil {
+                        for range uncheckedMetricChan {
+                        }
                 }
         }()
 
-collectLoop:
+        // Copy the channel references so we can nil them out later to remove
+        // them from the select statements below.
+        cmc := checkedMetricChan
+        umc := uncheckedMetricChan
+
         for {
                 select {
-                case metric, ok := <-metricChan:
+                case metric, ok := <-cmc:
                         if !ok {
-                                // metricChan is closed, we are done.
-                                break collectLoop
+                                cmc = nil
+                                break
                         }
                         errs.Append(processMetric(
                                 metric, metricFamiliesByName,
-                                metricHashes, dimHashes,
+                                metricHashes,
                                 registeredDescIDs,
                         ))
+                case metric, ok := <-umc:
+                        if !ok {
+                                umc = nil
+                                break
+                        }
+                        errs.Append(processMetric(
+                                metric, metricFamiliesByName,
+                                metricHashes,
+                                nil,
+                        ))
                 default:
-                        if goroutineBudget <= 0 || len(collectors) == 0 {
-                                // All collectors are aleady being worked on or
+                        if goroutineBudget <= 0 || len(checkedCollectors)+len(uncheckedCollectors) == 0 {
+                                // All collectors are already being worked on or
                                 // we have already as many goroutines started as
-                                // there are collectors. Just process metrics
-                                // from now on.
-                                for metric := range metricChan {
+                                // there are collectors. Do the same as above,
+                                // just without the default.
+                                select {
+                                case metric, ok := <-cmc:
+                                        if !ok {
+                                                cmc = nil
+                                                break
+                                        }
                                         errs.Append(processMetric(
                                                 metric, metricFamiliesByName,
-                                                metricHashes, dimHashes,
+                                                metricHashes,
                                                 registeredDescIDs,
                                         ))
+                                case metric, ok := <-umc:
+                                        if !ok {
+                                                umc = nil
+                                                break
+                                        }
+                                        errs.Append(processMetric(
+                                                metric, metricFamiliesByName,
+                                                metricHashes,
+                                                nil,
+                                        ))
                                 }
-                                break collectLoop
+                                break
                         }
                         // Start more workers.
                         go collectWorker()
                         goroutineBudget--
                         runtime.Gosched()
                 }
+                // Once both checkedMetricChan and uncheckdMetricChan are closed
+                // and drained, the contraption above will nil out cmc and umc,
+                // and then we can leave the collect loop here.
+                if cmc == nil && umc == nil {
+                        break
+                }
         }
-        return normalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
+        return internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
 }
 
 // processMetric is an internal helper method only used by the Gather method.
@@ -464,16 +536,20 @@ func processMetric(
         metric Metric,
         metricFamiliesByName map[string]*dto.MetricFamily,
         metricHashes map[uint64]struct{},
-        dimHashes map[string]uint64,
         registeredDescIDs map[uint64]struct{},
 ) error {
         desc := metric.Desc()
+        // Wrapped metrics collected by an unchecked Collector can have an
+        // invalid Desc.
+        if desc.err != nil {
+                return desc.err
+        }
         dtoMetric := &dto.Metric{}
         if err := metric.Write(dtoMetric); err != nil {
                 return fmt.Errorf("error collecting metric %v: %s", desc, err)
         }
         metricFamily, ok := metricFamiliesByName[desc.fqName]
-        if ok {
+        if ok { // Existing name.
                 if metricFamily.GetHelp() != desc.help {
                         return fmt.Errorf(
                                 "collected metric %s %s has help %q but should have %q",
@@ -520,7 +596,7 @@ func processMetric(
                 default:
                         panic("encountered MetricFamily with invalid type")
                 }
-        } else {
+        } else { // New name.
                 metricFamily = &dto.MetricFamily{}
                 metricFamily.Name = proto.String(desc.fqName)
                 metricFamily.Help = proto.String(desc.help)
@@ -539,9 +615,12 @@ func processMetric(
                 default:
                         return fmt.Errorf("empty metric collected: %s", dtoMetric)
                 }
+                if err := checkSuffixCollisions(metricFamily, metricFamiliesByName); err != nil {
+                        return err
+                }
                 metricFamiliesByName[desc.fqName] = metricFamily
         }
-        if err := checkMetricConsistency(metricFamily, dtoMetric, metricHashes, dimHashes); err != nil {
+        if err := checkMetricConsistency(metricFamily, dtoMetric, metricHashes); err != nil {
                 return err
         }
         if registeredDescIDs != nil {
@@ -583,7 +662,6 @@ func (gs Gatherers) Gather() ([]*dto.MetricFamily, error) {
         var (
                 metricFamiliesByName = map[string]*dto.MetricFamily{}
                 metricHashes         = map[uint64]struct{}{}
-                dimHashes            = map[string]uint64{}
                 errs                 MultiError // The collected errors to return in the end.
         )
 
@@ -620,10 +698,14 @@ func (gs Gatherers) Gather() ([]*dto.MetricFamily, error) {
                                 existingMF.Name = mf.Name
                                 existingMF.Help = mf.Help
                                 existingMF.Type = mf.Type
+                                if err := checkSuffixCollisions(existingMF, metricFamiliesByName); err != nil {
+                                        errs = append(errs, err)
+                                        continue
+                                }
                                 metricFamiliesByName[mf.GetName()] = existingMF
                         }
                         for _, m := range mf.Metric {
-                                if err := checkMetricConsistency(existingMF, m, metricHashes, dimHashes); err != nil {
+                                if err := checkMetricConsistency(existingMF, m, metricHashes); err != nil {
                                         errs = append(errs, err)
                                         continue
                                 }
@@ -631,87 +713,77 @@ func (gs Gatherers) Gather() ([]*dto.MetricFamily, error) {
                         }
                 }
         }
-        return normalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
+        return internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
 }
 
-// metricSorter is a sortable slice of *dto.Metric.
-type metricSorter []*dto.Metric
-
-func (s metricSorter) Len() int {
-        return len(s)
-}
-
-func (s metricSorter) Swap(i, j int) {
-        s[i], s[j] = s[j], s[i]
-}
-
-func (s metricSorter) Less(i, j int) bool {
-        if len(s[i].Label) != len(s[j].Label) {
-                // This should not happen. The metrics are
-                // inconsistent. However, we have to deal with the fact, as
-                // people might use custom collectors or metric family injection
-                // to create inconsistent metrics. So let's simply compare the
-                // number of labels in this case. That will still yield
-                // reproducible sorting.
-                return len(s[i].Label) < len(s[j].Label)
-        }
-        for n, lp := range s[i].Label {
-                vi := lp.GetValue()
-                vj := s[j].Label[n].GetValue()
-                if vi != vj {
-                        return vi < vj
+// checkSuffixCollisions checks for collisions with the “magic” suffixes the
+// Prometheus text format and the internal metric representation of the
+// Prometheus server add while flattening Summaries and Histograms.
+func checkSuffixCollisions(mf *dto.MetricFamily, mfs map[string]*dto.MetricFamily) error {
+        var (
+                newName              = mf.GetName()
+                newType              = mf.GetType()
+                newNameWithoutSuffix = ""
+        )
+        switch {
+        case strings.HasSuffix(newName, "_count"):
+                newNameWithoutSuffix = newName[:len(newName)-6]
+        case strings.HasSuffix(newName, "_sum"):
+                newNameWithoutSuffix = newName[:len(newName)-4]
+        case strings.HasSuffix(newName, "_bucket"):
+                newNameWithoutSuffix = newName[:len(newName)-7]
+        }
+        if newNameWithoutSuffix != "" {
+                if existingMF, ok := mfs[newNameWithoutSuffix]; ok {
+                        switch existingMF.GetType() {
+                        case dto.MetricType_SUMMARY:
+                                if !strings.HasSuffix(newName, "_bucket") {
+                                        return fmt.Errorf(
+                                                "collected metric named %q collides with previously collected summary named %q",
+                                                newName, newNameWithoutSuffix,
+                                        )
+                                }
+                        case dto.MetricType_HISTOGRAM:
+                                return fmt.Errorf(
+                                        "collected metric named %q collides with previously collected histogram named %q",
+                                        newName, newNameWithoutSuffix,
+                                )
+                        }
                 }
         }
-
-        // We should never arrive here. Multiple metrics with the same
-        // label set in the same scrape will lead to undefined ingestion
-        // behavior. However, as above, we have to provide stable sorting
-        // here, even for inconsistent metrics. So sort equal metrics
-        // by their timestamp, with missing timestamps (implying "now")
-        // coming last.
-        if s[i].TimestampMs == nil {
-                return false
-        }
-        if s[j].TimestampMs == nil {
-                return true
-        }
-        return s[i].GetTimestampMs() < s[j].GetTimestampMs()
-}
-
-// normalizeMetricFamilies returns a MetricFamily slice with empty
-// MetricFamilies pruned and the remaining MetricFamilies sorted by name within
-// the slice, with the contained Metrics sorted within each MetricFamily.
-func normalizeMetricFamilies(metricFamiliesByName map[string]*dto.MetricFamily) []*dto.MetricFamily {
-        for _, mf := range metricFamiliesByName {
-                sort.Sort(metricSorter(mf.Metric))
-        }
-        names := make([]string, 0, len(metricFamiliesByName))
-        for name, mf := range metricFamiliesByName {
-                if len(mf.Metric) > 0 {
-                        names = append(names, name)
+        if newType == dto.MetricType_SUMMARY || newType == dto.MetricType_HISTOGRAM {
+                if _, ok := mfs[newName+"_count"]; ok {
+                        return fmt.Errorf(
+                                "collected histogram or summary named %q collides with previously collected metric named %q",
+                                newName, newName+"_count",
+                        )
+                }
+                if _, ok := mfs[newName+"_sum"]; ok {
+                        return fmt.Errorf(
+                                "collected histogram or summary named %q collides with previously collected metric named %q",
+                                newName, newName+"_sum",
+                        )
                 }
         }
-        sort.Strings(names)
-        result := make([]*dto.MetricFamily, 0, len(names))
-        for _, name := range names {
-                result = append(result, metricFamiliesByName[name])
+        if newType == dto.MetricType_HISTOGRAM {
+                if _, ok := mfs[newName+"_bucket"]; ok {
+                        return fmt.Errorf(
+                                "collected histogram named %q collides with previously collected metric named %q",
+                                newName, newName+"_bucket",
+                        )
+                }
         }
-        return result
+        return nil
 }
 
 // checkMetricConsistency checks if the provided Metric is consistent with the
-// provided MetricFamily. It also hashed the Metric labels and the MetricFamily
+// provided MetricFamily. It also hashes the Metric labels and the MetricFamily
 // name. If the resulting hash is already in the provided metricHashes, an error
-// is returned. If not, it is added to metricHashes. The provided dimHashes maps
-// MetricFamily names to their dimHash (hashed sorted label names). If dimHashes
-// doesn't yet contain a hash for the provided MetricFamily, it is
-// added. Otherwise, an error is returned if the existing dimHashes in not equal
-// the calculated dimHash.
+// is returned. If not, it is added to metricHashes.
 func checkMetricConsistency(
         metricFamily *dto.MetricFamily,
         dtoMetric *dto.Metric,
         metricHashes map[uint64]struct{},
-        dimHashes map[string]uint64,
 ) error {
         // Type consistency with metric family.
         if metricFamily.GetType() == dto.MetricType_GAUGE && dtoMetric.Gauge == nil ||
@@ -720,47 +792,50 @@ func checkMetricConsistency(
                 metricFamily.GetType() == dto.MetricType_HISTOGRAM && dtoMetric.Histogram == nil ||
                 metricFamily.GetType() == dto.MetricType_UNTYPED && dtoMetric.Untyped == nil {
                 return fmt.Errorf(
-                        "collected metric %s %s is not a %s",
+                        "collected metric %q { %s} is not a %s",
                         metricFamily.GetName(), dtoMetric, metricFamily.GetType(),
                 )
         }
 
         for _, labelPair := range dtoMetric.GetLabel() {
-                if !utf8.ValidString(*labelPair.Value) {
-                        return fmt.Errorf("collected metric's label %s is not utf8: %#v", *labelPair.Name, *labelPair.Value)
+                if !checkLabelName(labelPair.GetName()) {
+                        return fmt.Errorf(
+                                "collected metric %q { %s} has a label with an invalid name: %s",
+                                metricFamily.GetName(), dtoMetric, labelPair.GetName(),
+                        )
+                }
+                if dtoMetric.Summary != nil && labelPair.GetName() == quantileLabel {
+                        return fmt.Errorf(
+                                "collected metric %q { %s} must not have an explicit %q label",
+                                metricFamily.GetName(), dtoMetric, quantileLabel,
+                        )
+                }
+                if !utf8.ValidString(labelPair.GetValue()) {
+                        return fmt.Errorf(
+                                "collected metric %q { %s} has a label named %q whose value is not utf8: %#v",
+                                metricFamily.GetName(), dtoMetric, labelPair.GetName(), labelPair.GetValue())
                 }
         }
 
-        // Is the metric unique (i.e. no other metric with the same name and the same label values)?
+        // Is the metric unique (i.e. no other metric with the same name and the same labels)?
         h := hashNew()
         h = hashAdd(h, metricFamily.GetName())
         h = hashAddByte(h, separatorByte)
-        dh := hashNew()
         // Make sure label pairs are sorted. We depend on it for the consistency
         // check.
-        sort.Sort(LabelPairSorter(dtoMetric.Label))
+        sort.Sort(labelPairSorter(dtoMetric.Label))
         for _, lp := range dtoMetric.Label {
+                h = hashAdd(h, lp.GetName())
+                h = hashAddByte(h, separatorByte)
                 h = hashAdd(h, lp.GetValue())
                 h = hashAddByte(h, separatorByte)
-                dh = hashAdd(dh, lp.GetName())
-                dh = hashAddByte(dh, separatorByte)
         }
         if _, exists := metricHashes[h]; exists {
                 return fmt.Errorf(
-                        "collected metric %s %s was collected before with the same name and label values",
+                        "collected metric %q { %s} was collected before with the same name and label values",
                         metricFamily.GetName(), dtoMetric,
                 )
         }
-        if dimHash, ok := dimHashes[metricFamily.GetName()]; ok {
-                if dimHash != dh {
-                        return fmt.Errorf(
-                                "collected metric %s %s has label dimensions inconsistent with previously collected metrics in the same metric family",
-                                metricFamily.GetName(), dtoMetric,
-                        )
-                }
-        } else {
-                dimHashes[metricFamily.GetName()] = dh
-        }
         metricHashes[h] = struct{}{}
         return nil
 }
@@ -792,7 +867,7 @@ func checkDescConsistency(
                         metricFamily.GetName(), dtoMetric, desc,
                 )
         }
-        sort.Sort(LabelPairSorter(lpsFromDesc))
+        sort.Sort(labelPairSorter(lpsFromDesc))
         for i, lpFromDesc := range lpsFromDesc {
                 lpFromMetric := dtoMetric.Label[i]
                 if lpFromDesc.GetName() != lpFromMetric.GetName() ||
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/summary.go b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
index f7dc85b..f7e92d8 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/summary.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
@@ -37,7 +37,7 @@ const quantileLabel = "quantile"
 // A typical use-case is the observation of request latencies. By default, a
 // Summary provides the median, the 90th and the 99th percentile of the latency
 // as rank estimations. However, the default behavior will change in the
-// upcoming v0.10 of the library. There will be no rank estiamtions at all by
+// upcoming v0.10 of the library. There will be no rank estimations at all by
 // default. For a sane transition, it is recommended to set the desired rank
 // estimations explicitly.
 //
@@ -81,10 +81,10 @@ const (
 )
 
 // SummaryOpts bundles the options for creating a Summary metric. It is
-// mandatory to set Name and Help to a non-empty string. While all other fields
-// are optional and can safely be left at their zero value, it is recommended to
-// explicitly set the Objectives field to the desired value as the default value
-// will change in the upcoming v0.10 of the library.
+// mandatory to set Name to a non-empty string. While all other fields are
+// optional and can safely be left at their zero value, it is recommended to set
+// a help string and to explicitly set the Objectives field to the desired value
+// as the default value will change in the upcoming v0.10 of the library.
 type SummaryOpts struct {
         // Namespace, Subsystem, and Name are components of the fully-qualified
         // name of the Summary (created by joining these components with
@@ -95,7 +95,7 @@ type SummaryOpts struct {
         Subsystem string
         Name      string
 
-        // Help provides information about this Summary. Mandatory!
+        // Help provides information about this Summary.
         //
         // Metrics with the same fully-qualified name must have the same Help
         // string.
@@ -105,6 +105,11 @@ type SummaryOpts struct {
         // with the same fully-qualified name must have the same label names in
         // their ConstLabels.
         //
+        // Due to the way a Summary is represented in the Prometheus text format
+        // and how it is handled by the Prometheus server internally, “quantile”
+        // is an illegal label name. Construction of a Summary or SummaryVec
+        // will panic if this label name is used in ConstLabels.
+        //
         // ConstLabels are only used rarely. In particular, do not use them to
         // attach the same labels to all your metrics. Those use cases are
         // better covered by target labels set by the scraping Prometheus
@@ -402,7 +407,16 @@ type SummaryVec struct {
 
 // NewSummaryVec creates a new SummaryVec based on the provided SummaryOpts and
 // partitioned by the given label names.
+//
+// Due to the way a Summary is represented in the Prometheus text format and how
+// it is handled by the Prometheus server internally, “quantile” is an illegal
+// label name. NewSummaryVec will panic if this label name is used.
 func NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec {
+        for _, ln := range labelNames {
+                if ln == quantileLabel {
+                        panic(errQuantileLabelNotAllowed)
+                }
+        }
         desc := NewDesc(
                 BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
                 opts.Help,
@@ -572,7 +586,7 @@ func (s *constSummary) Write(out *dto.Metric) error {
 //     map[float64]float64{0.5: 0.23, 0.99: 0.56}
 //
 // NewConstSummary returns an error if the length of labelValues is not
-// consistent with the variable labels in Desc.
+// consistent with the variable labels in Desc or if Desc is invalid.
 func NewConstSummary(
         desc *Desc,
         count uint64,
@@ -580,6 +594,9 @@ func NewConstSummary(
         quantiles map[float64]float64,
         labelValues ...string,
 ) (Metric, error) {
+        if desc.err != nil {
+                return nil, desc.err
+        }
         if err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {
                 return nil, err
         }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/value.go b/vendor/github.com/prometheus/client_golang/prometheus/value.go
index 543b57c..eb248f1 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/value.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/value.go
@@ -17,9 +17,9 @@ import (
         "fmt"
         "sort"
 
-        dto "github.com/prometheus/client_model/go"
-
         "github.com/golang/protobuf/proto"
+
+        dto "github.com/prometheus/client_model/go"
 )
 
 // ValueType is an enumeration of metric types that represent a simple value.
@@ -77,8 +77,12 @@ func (v *valueFunc) Write(out *dto.Metric) error {
 // operations. However, when implementing custom Collectors, it is useful as a
 // throw-away metric that is generated on the fly to send it to Prometheus in
 // the Collect method. NewConstMetric returns an error if the length of
-// labelValues is not consistent with the variable labels in Desc.
+// labelValues is not consistent with the variable labels in Desc or if Desc is
+// invalid.
 func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error) {
+        if desc.err != nil {
+                return nil, desc.err
+        }
         if err := validateLabelValues(labelValues, len(desc.variableLabels)); err != nil {
                 return nil, err
         }
@@ -152,9 +156,7 @@ func makeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair {
                         Value: proto.String(labelValues[i]),
                 })
         }
-        for _, lp := range desc.constLabelPairs {
-                labelPairs = append(labelPairs, lp)
-        }
-        sort.Sort(LabelPairSorter(labelPairs))
+        labelPairs = append(labelPairs, desc.constLabelPairs...)
+        sort.Sort(labelPairSorter(labelPairs))
         return labelPairs
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/vec.go b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
index cea1582..14ed9e8 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/vec.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
@@ -277,6 +277,9 @@ func (m *metricMap) deleteByHashWithLabelValues(
 func (m *metricMap) deleteByHashWithLabels(
         h uint64, labels Labels, curry []curriedLabelValue,
 ) bool {
+        m.mtx.Lock()
+        defer m.mtx.Unlock()
+
         metrics, ok := m.metrics[h]
         if !ok {
                 return false
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/wrap.go b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
new file mode 100644
index 0000000..49159bf
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
@@ -0,0 +1,179 @@
+// Copyright 2018 The Prometheus Authors
+// Licensed 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 prometheus
+
+import (
+        "fmt"
+        "sort"
+
+        "github.com/golang/protobuf/proto"
+
+        dto "github.com/prometheus/client_model/go"
+)
+
+// WrapRegistererWith returns a Registerer wrapping the provided
+// Registerer. Collectors registered with the returned Registerer will be
+// registered with the wrapped Registerer in a modified way. The modified
+// Collector adds the provided Labels to all Metrics it collects (as
+// ConstLabels). The Metrics collected by the unmodified Collector must not
+// duplicate any of those labels.
+//
+// WrapRegistererWith provides a way to add fixed labels to a subset of
+// Collectors. It should not be used to add fixed labels to all metrics exposed.
+//
+// The Collector example demonstrates a use of WrapRegistererWith.
+func WrapRegistererWith(labels Labels, reg Registerer) Registerer {
+        return &wrappingRegisterer{
+                wrappedRegisterer: reg,
+                labels:            labels,
+        }
+}
+
+// WrapRegistererWithPrefix returns a Registerer wrapping the provided
+// Registerer. Collectors registered with the returned Registerer will be
+// registered with the wrapped Registerer in a modified way. The modified
+// Collector adds the provided prefix to the name of all Metrics it collects.
+//
+// WrapRegistererWithPrefix is useful to have one place to prefix all metrics of
+// a sub-system. To make this work, register metrics of the sub-system with the
+// wrapping Registerer returned by WrapRegistererWithPrefix. It is rarely useful
+// to use the same prefix for all metrics exposed. In particular, do not prefix
+// metric names that are standardized across applications, as that would break
+// horizontal monitoring, for example the metrics provided by the Go collector
+// (see NewGoCollector) and the process collector (see NewProcessCollector). (In
+// fact, those metrics are already prefixed with “go_” or “process_”,
+// respectively.)
+func WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer {
+        return &wrappingRegisterer{
+                wrappedRegisterer: reg,
+                prefix:            prefix,
+        }
+}
+
+type wrappingRegisterer struct {
+        wrappedRegisterer Registerer
+        prefix            string
+        labels            Labels
+}
+
+func (r *wrappingRegisterer) Register(c Collector) error {
+        return r.wrappedRegisterer.Register(&wrappingCollector{
+                wrappedCollector: c,
+                prefix:           r.prefix,
+                labels:           r.labels,
+        })
+}
+
+func (r *wrappingRegisterer) MustRegister(cs ...Collector) {
+        for _, c := range cs {
+                if err := r.Register(c); err != nil {
+                        panic(err)
+                }
+        }
+}
+
+func (r *wrappingRegisterer) Unregister(c Collector) bool {
+        return r.wrappedRegisterer.Unregister(&wrappingCollector{
+                wrappedCollector: c,
+                prefix:           r.prefix,
+                labels:           r.labels,
+        })
+}
+
+type wrappingCollector struct {
+        wrappedCollector Collector
+        prefix           string
+        labels           Labels
+}
+
+func (c *wrappingCollector) Collect(ch chan<- Metric) {
+        wrappedCh := make(chan Metric)
+        go func() {
+                c.wrappedCollector.Collect(wrappedCh)
+                close(wrappedCh)
+        }()
+        for m := range wrappedCh {
+                ch <- &wrappingMetric{
+                        wrappedMetric: m,
+                        prefix:        c.prefix,
+                        labels:        c.labels,
+                }
+        }
+}
+
+func (c *wrappingCollector) Describe(ch chan<- *Desc) {
+        wrappedCh := make(chan *Desc)
+        go func() {
+                c.wrappedCollector.Describe(wrappedCh)
+                close(wrappedCh)
+        }()
+        for desc := range wrappedCh {
+                ch <- wrapDesc(desc, c.prefix, c.labels)
+        }
+}
+
+type wrappingMetric struct {
+        wrappedMetric Metric
+        prefix        string
+        labels        Labels
+}
+
+func (m *wrappingMetric) Desc() *Desc {
+        return wrapDesc(m.wrappedMetric.Desc(), m.prefix, m.labels)
+}
+
+func (m *wrappingMetric) Write(out *dto.Metric) error {
+        if err := m.wrappedMetric.Write(out); err != nil {
+                return err
+        }
+        if len(m.labels) == 0 {
+                // No wrapping labels.
+                return nil
+        }
+        for ln, lv := range m.labels {
+                out.Label = append(out.Label, &dto.LabelPair{
+                        Name:  proto.String(ln),
+                        Value: proto.String(lv),
+                })
+        }
+        sort.Sort(labelPairSorter(out.Label))
+        return nil
+}
+
+func wrapDesc(desc *Desc, prefix string, labels Labels) *Desc {
+        constLabels := Labels{}
+        for _, lp := range desc.constLabelPairs {
+                constLabels[*lp.Name] = *lp.Value
+        }
+        for ln, lv := range labels {
+                if _, alreadyUsed := constLabels[ln]; alreadyUsed {
+                        return &Desc{
+                                fqName:          desc.fqName,
+                                help:            desc.help,
+                                variableLabels:  desc.variableLabels,
+                                constLabelPairs: desc.constLabelPairs,
+                                err:             fmt.Errorf("attempted wrapping with already existing label name %q", ln),
+                        }
+                }
+                constLabels[ln] = lv
+        }
+        // NewDesc will do remaining validations.
+        newDesc := NewDesc(prefix+desc.fqName, desc.help, desc.variableLabels, constLabels)
+        // Propagate errors if there was any. This will override any errer
+        // created by NewDesc above, i.e. earlier errors get precedence.
+        if desc.err != nil {
+                newDesc.err = desc.err
+        }
+        return newDesc
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 02667b6..a807c9c 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -115,16 +115,22 @@
                         "revisionTime": "2017-09-01T18:29:50Z"
                 },
                 {
-                        "checksumSHA1": "I87tkF1e/hrl4d/XIKFfkPRq1ww=",
+                        "checksumSHA1": "lLvg5TpUtFbkyAoh+aI5T/nnpWw=",
                         "path": "github.com/prometheus/client_golang/prometheus",
-                        "revision": "e69720d204a4aa3b0c65dc91208645ba0a52b9cd",
-                        "revisionTime": "2018-02-16T13:12:53Z"
+                        "revision": "e637cec7d9c8990247098639ebc6d43dd34ddd49",
+                        "revisionTime": "2018-09-17T10:21:22Z"
                 },
                 {
-                        "checksumSHA1": "mIWVz1E1QJ6yZnf7ELNwLboyK4w=",
+                        "checksumSHA1": "UBqhkyjCz47+S19MVTigxJ2VjVQ=",
+                        "path": "github.com/prometheus/client_golang/prometheus/internal",
+                        "revision": "e637cec7d9c8990247098639ebc6d43dd34ddd49",
+                        "revisionTime": "2018-09-17T10:21:22Z"
+                },
+                {
+                        "checksumSHA1": "d5BiEvD8MrgpWQ6PQJUvawJsMak=",
                         "path": "github.com/prometheus/client_golang/prometheus/promhttp",
-                        "revision": "e69720d204a4aa3b0c65dc91208645ba0a52b9cd",
-                        "revisionTime": "2018-02-16T13:12:53Z"
+                        "revision": "e637cec7d9c8990247098639ebc6d43dd34ddd49",
+                        "revisionTime": "2018-09-17T10:21:22Z"
                 },
                 {
                         "checksumSHA1": "DvwvOlPNAgRntBzt3b3OSRMS2N4=",