23 files changed, 896 insertions, 1068 deletions

diff --git a/go.mod b/go.mod
index 717ee8e..7fa5042 100644
--- a/go.mod
+++ b/go.mod
@@ -2,11 +2,9 @@ module github.com/prometheus/node_exporter
 
 require (
         github.com/beevik/ntp v0.2.0
-        github.com/beorn7/perks v1.0.0 // indirect
         github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e
         github.com/ema/qdisc v0.0.0-20180104102928-b307c22d3ce7
         github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968
-        github.com/golang/protobuf v1.3.1 // indirect
         github.com/google/go-cmp v0.3.0 // indirect
         github.com/hodgesds/perf-utils v0.0.7
         github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
@@ -15,14 +13,13 @@ require (
         github.com/mdlayher/genetlink v0.0.0-20181016160152-e97704c1b795 // indirect
         github.com/mdlayher/netlink v0.0.0-20181210160939-e069752bc835 // indirect
         github.com/mdlayher/wifi v0.0.0-20180727163819-efdf3f4195d9
-        github.com/prometheus/client_golang v0.9.2
+        github.com/prometheus/client_golang v1.0.0
         github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90
-        github.com/prometheus/common v0.3.0
+        github.com/prometheus/common v0.4.1
         github.com/prometheus/procfs v0.0.2
         github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745
         github.com/sirupsen/logrus v1.4.2 // indirect
         github.com/soundcloud/go-runit v0.0.0-20150630195641-06ad41a06c4a
-        github.com/stretchr/testify v1.3.0 // indirect
         go.uber.org/atomic v1.3.2 // indirect
         go.uber.org/multierr v1.1.0 // indirect
         golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c // indirect
diff --git a/go.sum b/go.sum
index e96c2ec..d7b9a33 100644
--- a/go.sum
+++ b/go.sum
@@ -30,6 +30,7 @@ github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/hodgesds/perf-utils v0.0.7 h1:V/5aRKeXn/membOpFdzAgd+fFvmtvTYD6moDuZ7K7SM=
 github.com/hodgesds/perf-utils v0.0.7/go.mod h1:F6TfvsbtrF88i++hou29dTXlI2sfsJv+gRZDtmTJkAs=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -48,23 +49,23 @@ github.com/mdlayher/netlink v0.0.0-20181210160939-e069752bc835 h1:WpZONc7LNdfPrl
 github.com/mdlayher/netlink v0.0.0-20181210160939-e069752bc835/go.mod h1:a3TlQHkJH2m32RF224Z7LhD5N4mpyR8eUbCoYHywrwg=
 github.com/mdlayher/wifi v0.0.0-20180727163819-efdf3f4195d9 h1:ag57ienknXLMhoSbkYvaZLF9Taxu9GtBHUJ4jP5ER8s=
 github.com/mdlayher/wifi v0.0.0-20180727163819-efdf3f4195d9/go.mod h1:Evt/EIne46u9PtQbeTx2NTcqURpr5K4SvKtGmBuDPN8=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v0.9.1 h1:K47Rk0v/fkEfwfQet2KWhscE0cJzjgCCDBG2KHZoVno=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v0.9.2 h1:awm861/B8OKDd2I/6o1dy3ra4BamzKhYOiGItCeZ740=
-github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
+github.com/prometheus/client_golang v1.0.0 h1:vrDKnkGzuGvhNAL56c7DBz29ZL+KxnoR0x7enabFceM=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/common v0.3.0 h1:taZ4h8Tkxv2kNyoSctBvfXEHmBmxrwmIidZTIaHons4=
-github.com/prometheus/common v0.3.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1 h1:K0MGApIoQvMw27RTdJkPbr3JZ7DNbtxQNyi5STVM6Kw=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745 h1:IuH7WumZNax0D+rEqmy2TyhKCzrtMGqbZO0b8rO00JA=
@@ -87,7 +88,6 @@ go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw=
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/build_info.go b/vendor/github.com/prometheus/client_golang/prometheus/build_info.go
new file mode 100644
index 0000000..288f0e8
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/build_info.go
@@ -0,0 +1,29 @@
+// Copyright 2019 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.
+
+// +build go1.12
+
+package prometheus
+
+import "runtime/debug"
+
+// readBuildInfo is a wrapper around debug.ReadBuildInfo for Go 1.12+.
+func readBuildInfo() (path, version, sum string) {
+        path, version, sum = "unknown", "unknown", "unknown"
+        if bi, ok := debug.ReadBuildInfo(); ok {
+                path = bi.Main.Path
+                version = bi.Main.Version
+                sum = bi.Main.Sum
+        }
+        return
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/build_info_pre_1.12.go b/vendor/github.com/prometheus/client_golang/prometheus/build_info_pre_1.12.go
new file mode 100644
index 0000000..6609e28
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/build_info_pre_1.12.go
@@ -0,0 +1,22 @@
+// Copyright 2019 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.
+
+// +build !go1.12
+
+package prometheus
+
+// readBuildInfo is a wrapper around debug.ReadBuildInfo for Go versions before
+// 1.12. Remove this whole file once the minimum supported Go version is 1.12.
+func readBuildInfo() (path, version, sum string) {
+        return "unknown", "unknown", "unknown"
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/collector.go b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
index c0d70b2..1e83965 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
@@ -79,7 +79,7 @@ type Collector interface {
 // 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
+// it might even get registered as an unchecked Collector (cf. the Register
 // method of the Registerer interface). Hence, only use this shortcut
 // implementation of Describe if you are certain to fulfill the contract.
 //
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/doc.go b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
index 5d9525d..01977de 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/doc.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
@@ -122,13 +122,13 @@
 // 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. 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
+// could return no Desc at all, which will mark the Collector “unchecked”.  No
+// checks are performed 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
+// sometimes necessary. The typical use case is a situation 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.
@@ -183,7 +183,6 @@
 // method can then expose the gathered metrics in some way. Usually, the metrics
 // are served via HTTP on the /metrics endpoint. That's happening in the example
 // above. The tools to expose metrics via HTTP are in the promhttp sub-package.
-// (The top-level functions in the prometheus package are deprecated.)
 //
 // Pushing to the Pushgateway
 //
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 ba3b933..dc9247f 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
@@ -14,9 +14,9 @@
 package prometheus
 
 import (
-        "fmt"
         "runtime"
         "runtime/debug"
+        "sync"
         "time"
 )
 
@@ -26,16 +26,41 @@ type goCollector struct {
         gcDesc         *Desc
         goInfoDesc     *Desc
 
-        // metrics to describe and collect
-        metrics memStatsMetrics
+        // ms... are memstats related.
+        msLast          *runtime.MemStats // Previously collected memstats.
+        msLastTimestamp time.Time
+        msMtx           sync.Mutex // Protects msLast and msLastTimestamp.
+        msMetrics       memStatsMetrics
+        msRead          func(*runtime.MemStats) // For mocking in tests.
+        msMaxWait       time.Duration           // Wait time for fresh memstats.
+        msMaxAge        time.Duration           // Maximum allowed age of old memstats.
 }
 
-// NewGoCollector returns a collector which exports metrics about the current Go
+// NewGoCollector returns a collector that 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
+// is called. This requires to “stop the world”, which usually only happens for
+// garbage collection (GC). Take the following implications into account when
+// deciding whether to use the Go collector:
+//
+// 1. The performance impact of stopping the world is the more relevant the more
+// frequently metrics are collected. However, with Go1.9 or later the
+// stop-the-world time per metrics collection is very short (~25µs) so that the
+// performance impact will only matter in rare cases. 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).
+//
+// 2. During an ongoing GC, nothing else can stop the world. Therefore, if the
+// metrics collection happens to coincide with GC, it will only complete after
+// GC has finished. Usually, GC is fast enough to not cause problems. However,
+// with a very large heap, GC might take multiple seconds, which is enough to
+// cause scrape timeouts in common setups. To avoid this problem, the Go
+// collector will use the memstats from a previous collection if
+// runtime.ReadMemStats takes more than 1s. However, if there are no previously
+// collected memstats, or their collection is more than 5m ago, the collection
+// will block until runtime.ReadMemStats succeeds. (The problem might be solved
+// in Go1.13, see https://github.com/golang/go/issues/19812 for the related Go
+// issue.)
 func NewGoCollector() Collector {
         return &goCollector{
                 goroutinesDesc: NewDesc(
@@ -54,7 +79,11 @@ func NewGoCollector() Collector {
                         "go_info",
                         "Information about the Go environment.",
                         nil, Labels{"version": runtime.Version()}),
-                metrics: memStatsMetrics{
+                msLast:    &runtime.MemStats{},
+                msRead:    runtime.ReadMemStats,
+                msMaxWait: time.Second,
+                msMaxAge:  5 * time.Minute,
+                msMetrics: memStatsMetrics{
                         {
                                 desc: NewDesc(
                                         memstatNamespace("alloc_bytes"),
@@ -253,7 +282,7 @@ func NewGoCollector() Collector {
 }
 
 func memstatNamespace(s string) string {
-        return fmt.Sprintf("go_memstats_%s", s)
+        return "go_memstats_" + s
 }
 
 // Describe returns all descriptions of the collector.
@@ -262,13 +291,27 @@ func (c *goCollector) Describe(ch chan<- *Desc) {
         ch <- c.threadsDesc
         ch <- c.gcDesc
         ch <- c.goInfoDesc
-        for _, i := range c.metrics {
+        for _, i := range c.msMetrics {
                 ch <- i.desc
         }
 }
 
 // Collect returns the current state of all metrics of the collector.
 func (c *goCollector) Collect(ch chan<- Metric) {
+        var (
+                ms   = &runtime.MemStats{}
+                done = make(chan struct{})
+        )
+        // Start reading memstats first as it might take a while.
+        go func() {
+                c.msRead(ms)
+                c.msMtx.Lock()
+                c.msLast = ms
+                c.msLastTimestamp = time.Now()
+                c.msMtx.Unlock()
+                close(done)
+        }()
+
         ch <- MustNewConstMetric(c.goroutinesDesc, GaugeValue, float64(runtime.NumGoroutine()))
         n, _ := runtime.ThreadCreateProfile(nil)
         ch <- MustNewConstMetric(c.threadsDesc, GaugeValue, float64(n))
@@ -286,9 +329,31 @@ func (c *goCollector) Collect(ch chan<- Metric) {
 
         ch <- MustNewConstMetric(c.goInfoDesc, GaugeValue, 1)
 
-        ms := &runtime.MemStats{}
-        runtime.ReadMemStats(ms)
-        for _, i := range c.metrics {
+        timer := time.NewTimer(c.msMaxWait)
+        select {
+        case <-done: // Our own ReadMemStats succeeded in time. Use it.
+                timer.Stop() // Important for high collection frequencies to not pile up timers.
+                c.msCollect(ch, ms)
+                return
+        case <-timer.C: // Time out, use last memstats if possible. Continue below.
+        }
+        c.msMtx.Lock()
+        if time.Since(c.msLastTimestamp) < c.msMaxAge {
+                // Last memstats are recent enough. Collect from them under the lock.
+                c.msCollect(ch, c.msLast)
+                c.msMtx.Unlock()
+                return
+        }
+        // If we are here, the last memstats are too old or don't exist. We have
+        // to wait until our own ReadMemStats finally completes. For that to
+        // happen, we have to release the lock.
+        c.msMtx.Unlock()
+        <-done
+        c.msCollect(ch, ms)
+}
+
+func (c *goCollector) msCollect(ch chan<- Metric, ms *runtime.MemStats) {
+        for _, i := range c.msMetrics {
                 ch <- MustNewConstMetric(i.desc, i.valType, i.eval(ms))
         }
 }
@@ -299,3 +364,33 @@ type memStatsMetrics []struct {
         eval    func(*runtime.MemStats) float64
         valType ValueType
 }
+
+// NewBuildInfoCollector returns a collector collecting a single metric
+// "go_build_info" with the constant value 1 and three labels "path", "version",
+// and "checksum". Their label values contain the main module path, version, and
+// checksum, respectively. The labels will only have meaningful values if the
+// binary is built with Go module support and from source code retrieved from
+// the source repository (rather than the local file system). This is usually
+// accomplished by building from outside of GOPATH, specifying the full address
+// of the main package, e.g. "GO111MODULE=on go run
+// github.com/prometheus/client_golang/examples/random". If built without Go
+// module support, all label values will be "unknown". If built with Go module
+// support but using the source code from the local file system, the "path" will
+// be set appropriately, but "checksum" will be empty and "version" will be
+// "(devel)".
+//
+// This collector uses only the build information for the main module. See
+// https://github.com/povilasv/prommod for an example of a collector for the
+// module dependencies.
+func NewBuildInfoCollector() Collector {
+        path, version, sum := readBuildInfo()
+        c := &selfCollector{MustNewConstMetric(
+                NewDesc(
+                        "go_build_info",
+                        "Build information about the main Go module.",
+                        nil, Labels{"path": path, "version": version, "checksum": sum},
+                ),
+                GaugeValue, 1)}
+        c.init(c.self)
+        return c
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
index f88da70..d7ea67b 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
@@ -204,8 +204,8 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr
                         }
                 }
         }
-        // Finally we know the final length of h.upperBounds and can make counts
-        // for both states:
+        // Finally we know the final length of h.upperBounds and can make buckets
+        // for both counts:
         h.counts[0].buckets = make([]uint64, len(h.upperBounds))
         h.counts[1].buckets = make([]uint64, len(h.upperBounds))
 
@@ -224,18 +224,21 @@ type histogramCounts struct {
 }
 
 type histogram struct {
-        // countAndHotIdx 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 enables lock-free writes with use of atomic updates.
+        // The most significant bit is the hot index [0 or 1] of the count field
+        // below. Observe calls update the hot one. All remaining bits count the
+        // number of Observe calls. Observe starts by incrementing this counter,
+        // and finish by incrementing the count field in the respective
+        // histogramCounts, as a marker for completion.
         //
-        // This has to be first in the struct for 64bit alignment. See
+        // Calls of the Write method (which are non-mutating reads from the
+        // perspective of the histogram) swap the hot–cold under the writeMtx
+        // lock. A cooldown is awaited (while locked) by comparing the number of
+        // observations with the initiation count. Once they match, then the
+        // last observation on the now cool one has completed. All cool fields must
+        // be merged into the new hot before releasing writeMtx.
+        //
+        // Fields with atomic access first! See alignment constraint:
         // http://golang.org/pkg/sync/atomic/#pkg-note-BUG
         countAndHotIdx uint64
 
@@ -243,16 +246,14 @@ type histogram struct {
         desc     *Desc
         writeMtx sync.Mutex // Only used in the Write method.
 
-        upperBounds []float64
-
         // Two counts, one is "hot" for lock-free observations, the other is
         // "cold" for writing out a dto.Metric. It has to be an array of
         // pointers to guarantee 64bit alignment of the histogramCounts, see
         // http://golang.org/pkg/sync/atomic/#pkg-note-BUG.
         counts [2]*histogramCounts
-        hotIdx int // Index of currently-hot counts. Only used within Write.
 
-        labelPairs []*dto.LabelPair
+        upperBounds []float64
+        labelPairs  []*dto.LabelPair
 }
 
 func (h *histogram) Desc() *Desc {
@@ -271,11 +272,11 @@ func (h *histogram) Observe(v float64) {
         // 300 buckets: 154 ns/op linear - binary 61.6 ns/op
         i := sort.SearchFloat64s(h.upperBounds, v)
 
-        // 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
+        // We increment h.countAndHotIdx so that the counter in the lower
+        // 63 bits gets incremented. 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]
+        n := atomic.AddUint64(&h.countAndHotIdx, 1)
+        hotCounts := h.counts[n>>63]
 
         if i < len(h.upperBounds) {
                 atomic.AddUint64(&hotCounts.buckets[i], 1)
@@ -293,72 +294,43 @@ func (h *histogram) Observe(v float64) {
 }
 
 func (h *histogram) Write(out *dto.Metric) error {
-        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.
+        // For simplicity, we protect this whole method by a mutex. 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, if possible at
+        // all.
         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
-                }
+        // Adding 1<<63 switches the hot index (from 0 to 1 or from 1 to 0)
+        // without touching the count bits. See the struct comments for a full
+        // description of the algorithm.
+        n := atomic.AddUint64(&h.countAndHotIdx, 1<<63)
+        // count is contained unchanged in the lower 63 bits.
+        count := n & ((1 << 63) - 1)
+        // The most significant bit tells us which counts is hot. The complement
+        // is thus the cold one.
+        hotCounts := h.counts[n>>63]
+        coldCounts := h.counts[(^n)>>63]
+
+        // Await cooldown.
+        for count != atomic.LoadUint64(&coldCounts.count) {
                 runtime.Gosched() // Let observations get work done.
         }
 
-        his.SampleCount = proto.Uint64(count)
-        his.SampleSum = proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits)))
+        his := &dto.Histogram{
+                Bucket:      make([]*dto.Bucket, len(h.upperBounds)),
+                SampleCount: proto.Uint64(count),
+                SampleSum:   proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),
+        }
         var cumCount uint64
         for i, upperBound := range h.upperBounds {
                 cumCount += atomic.LoadUint64(&coldCounts.buckets[i])
-                buckets[i] = &dto.Bucket{
+                his.Bucket[i] = &dto.Bucket{
                         CumulativeCount: proto.Uint64(cumCount),
                         UpperBound:      proto.Float64(upperBound),
                 }
         }
 
-        his.Bucket = buckets
         out.Histogram = his
         out.Label = h.labelPairs
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/http.go b/vendor/github.com/prometheus/client_golang/prometheus/http.go
deleted file mode 100644
index 9f0875b..0000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/http.go
+++ /dev/null
@@ -1,504 +0,0 @@
-// Copyright 2014 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 (
-        "bufio"
-        "compress/gzip"
-        "io"
-        "net"
-        "net/http"
-        "strconv"
-        "strings"
-        "sync"
-        "time"
-
-        "github.com/prometheus/common/expfmt"
-)
-
-// TODO(beorn7): Remove this whole file. It is a partial mirror of
-// promhttp/http.go (to avoid circular import chains) where everything HTTP
-// related should live. The functions here are just for avoiding
-// breakage. Everything is deprecated.
-
-const (
-        contentTypeHeader     = "Content-Type"
-        contentLengthHeader   = "Content-Length"
-        contentEncodingHeader = "Content-Encoding"
-        acceptEncodingHeader  = "Accept-Encoding"
-)
-
-var gzipPool = sync.Pool{
-        New: func() interface{} {
-                return gzip.NewWriter(nil)
-        },
-}
-
-// Handler returns an HTTP handler for the DefaultGatherer. It is
-// already instrumented with InstrumentHandler (using "prometheus" as handler
-// name).
-//
-// Deprecated: Please note the issues described in the doc comment of
-// 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.HandlerFor(DefaultGatherer, promhttp.HandlerOpts{})
-// instead. See there for further documentation.
-func UninstrumentedHandler() http.Handler {
-        return http.HandlerFunc(func(rsp http.ResponseWriter, req *http.Request) {
-                mfs, err := DefaultGatherer.Gather()
-                if err != nil {
-                        httpError(rsp, err)
-                        return
-                }
-
-                contentType := expfmt.Negotiate(req.Header)
-                header := rsp.Header()
-                header.Set(contentTypeHeader, string(contentType))
-
-                w := io.Writer(rsp)
-                if gzipAccepted(req.Header) {
-                        header.Set(contentEncodingHeader, "gzip")
-                        gz := gzipPool.Get().(*gzip.Writer)
-                        defer gzipPool.Put(gz)
-
-                        gz.Reset(w)
-                        defer gz.Close()
-
-                        w = gz
-                }
-
-                enc := expfmt.NewEncoder(w, contentType)
-
-                for _, mf := range mfs {
-                        if err := enc.Encode(mf); err != nil {
-                                httpError(rsp, err)
-                                return
-                        }
-                }
-        })
-}
-
-var instLabels = []string{"method", "code"}
-
-type nower interface {
-        Now() time.Time
-}
-
-type nowFunc func() time.Time
-
-func (n nowFunc) Now() time.Time {
-        return n()
-}
-
-var now nower = nowFunc(func() time.Time {
-        return time.Now()
-})
-
-// 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
-// (CounterVec), http_request_duration_microseconds (Summary),
-// http_request_size_bytes (Summary), http_response_size_bytes (Summary). Each
-// has a constant label named "handler" with the provided handlerName as
-// value. http_requests_total is a metric vector partitioned by HTTP method
-// (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: (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)
-}
-
-// InstrumentHandlerFunc wraps the given function for instrumentation. It
-// otherwise works in the same way as InstrumentHandler (and shares the same
-// issues).
-//
-// Deprecated: InstrumentHandlerFunc is deprecated for the same reasons as
-// InstrumentHandler is. Use the tooling provided in package promhttp instead.
-func InstrumentHandlerFunc(handlerName string, handlerFunc func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-        return InstrumentHandlerFuncWithOpts(
-                SummaryOpts{
-                        Subsystem:   "http",
-                        ConstLabels: Labels{"handler": handlerName},
-                        Objectives:  map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
-                },
-                handlerFunc,
-        )
-}
-
-// InstrumentHandlerWithOpts works like InstrumentHandler (and shares the same
-// issues) but provides more flexibility (at the cost of a more complex call
-// syntax). As InstrumentHandler, this function registers four metric
-// collectors, but it uses the provided SummaryOpts to create them. However, the
-// fields "Name" and "Help" in the SummaryOpts are ignored. "Name" is replaced
-// by "requests_total", "request_duration_microseconds", "request_size_bytes",
-// and "response_size_bytes", respectively. "Help" is replaced by an appropriate
-// help string. The names of the variable labels of the http_requests_total
-// CounterVec are "method" (get, post, etc.), and "code" (HTTP status code).
-//
-// If InstrumentHandlerWithOpts is called as follows, it mimics exactly the
-// behavior of InstrumentHandler:
-//
-//     prometheus.InstrumentHandlerWithOpts(
-//         prometheus.SummaryOpts{
-//              Subsystem:   "http",
-//              ConstLabels: prometheus.Labels{"handler": handlerName},
-//         },
-//         handler,
-//     )
-//
-// Technical detail: "requests_total" is a CounterVec, not a SummaryVec, so it
-// cannot use SummaryOpts. Instead, a CounterOpts struct is created internally,
-// and all its fields are set to the equally named fields in the provided
-// SummaryOpts.
-//
-// Deprecated: InstrumentHandlerWithOpts is deprecated for the same reasons as
-// InstrumentHandler is. Use the tooling provided in package promhttp instead.
-func InstrumentHandlerWithOpts(opts SummaryOpts, handler http.Handler) http.HandlerFunc {
-        return InstrumentHandlerFuncWithOpts(opts, handler.ServeHTTP)
-}
-
-// InstrumentHandlerFuncWithOpts works like InstrumentHandlerFunc (and shares
-// the same issues) but provides more flexibility (at the cost of a more complex
-// call syntax). See InstrumentHandlerWithOpts for details how the provided
-// SummaryOpts are used.
-//
-// Deprecated: InstrumentHandlerFuncWithOpts is deprecated for the same reasons
-// as InstrumentHandler is. Use the tooling provided in package promhttp instead.
-func InstrumentHandlerFuncWithOpts(opts SummaryOpts, handlerFunc func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
-        reqCnt := NewCounterVec(
-                CounterOpts{
-                        Namespace:   opts.Namespace,
-                        Subsystem:   opts.Subsystem,
-                        Name:        "requests_total",
-                        Help:        "Total number of HTTP requests made.",
-                        ConstLabels: opts.ConstLabels,
-                },
-                instLabels,
-        )
-        if err := Register(reqCnt); err != nil {
-                if are, ok := err.(AlreadyRegisteredError); ok {
-                        reqCnt = are.ExistingCollector.(*CounterVec)
-                } else {
-                        panic(err)
-                }
-        }
-
-        opts.Name = "request_duration_microseconds"
-        opts.Help = "The HTTP request latencies in microseconds."
-        reqDur := NewSummary(opts)
-        if err := Register(reqDur); err != nil {
-                if are, ok := err.(AlreadyRegisteredError); ok {
-                        reqDur = are.ExistingCollector.(Summary)
-                } else {
-                        panic(err)
-                }
-        }
-
-        opts.Name = "request_size_bytes"
-        opts.Help = "The HTTP request sizes in bytes."
-        reqSz := NewSummary(opts)
-        if err := Register(reqSz); err != nil {
-                if are, ok := err.(AlreadyRegisteredError); ok {
-                        reqSz = are.ExistingCollector.(Summary)
-                } else {
-                        panic(err)
-                }
-        }
-
-        opts.Name = "response_size_bytes"
-        opts.Help = "The HTTP response sizes in bytes."
-        resSz := NewSummary(opts)
-        if err := Register(resSz); err != nil {
-                if are, ok := err.(AlreadyRegisteredError); ok {
-                        resSz = are.ExistingCollector.(Summary)
-                } else {
-                        panic(err)
-                }
-        }
-
-        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-                now := time.Now()
-
-                delegate := &responseWriterDelegator{ResponseWriter: w}
-                out := computeApproximateRequestSize(r)
-
-                _, cn := w.(http.CloseNotifier)
-                _, fl := w.(http.Flusher)
-                _, hj := w.(http.Hijacker)
-                _, rf := w.(io.ReaderFrom)
-                var rw http.ResponseWriter
-                if cn && fl && hj && rf {
-                        rw = &fancyResponseWriterDelegator{delegate}
-                } else {
-                        rw = delegate
-                }
-                handlerFunc(rw, r)
-
-                elapsed := float64(time.Since(now)) / float64(time.Microsecond)
-
-                method := sanitizeMethod(r.Method)
-                code := sanitizeCode(delegate.status)
-                reqCnt.WithLabelValues(method, code).Inc()
-                reqDur.Observe(elapsed)
-                resSz.Observe(float64(delegate.written))
-                reqSz.Observe(float64(<-out))
-        })
-}
-
-func computeApproximateRequestSize(r *http.Request) <-chan int {
-        // 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 {
-                s += len(r.URL.String())
-        }
-
-        out := make(chan int, 1)
-
-        go func() {
-                s += len(r.Method)
-                s += len(r.Proto)
-                for name, values := range r.Header {
-                        s += len(name)
-                        for _, value := range values {
-                                s += len(value)
-                        }
-                }
-                s += len(r.Host)
-
-                // N.B. r.Form and r.MultipartForm are assumed to be included in r.URL.
-
-                if r.ContentLength != -1 {
-                        s += int(r.ContentLength)
-                }
-                out <- s
-                close(out)
-        }()
-
-        return out
-}
-
-type responseWriterDelegator struct {
-        http.ResponseWriter
-
-        status      int
-        written     int64
-        wroteHeader bool
-}
-
-func (r *responseWriterDelegator) WriteHeader(code int) {
-        r.status = code
-        r.wroteHeader = true
-        r.ResponseWriter.WriteHeader(code)
-}
-
-func (r *responseWriterDelegator) Write(b []byte) (int, error) {
-        if !r.wroteHeader {
-                r.WriteHeader(http.StatusOK)
-        }
-        n, err := r.ResponseWriter.Write(b)
-        r.written += int64(n)
-        return n, err
-}
-
-type fancyResponseWriterDelegator struct {
-        *responseWriterDelegator
-}
-
-func (f *fancyResponseWriterDelegator) CloseNotify() <-chan bool {
-        return f.ResponseWriter.(http.CloseNotifier).CloseNotify()
-}
-
-func (f *fancyResponseWriterDelegator) Flush() {
-        f.ResponseWriter.(http.Flusher).Flush()
-}
-
-func (f *fancyResponseWriterDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-        return f.ResponseWriter.(http.Hijacker).Hijack()
-}
-
-func (f *fancyResponseWriterDelegator) ReadFrom(r io.Reader) (int64, error) {
-        if !f.wroteHeader {
-                f.WriteHeader(http.StatusOK)
-        }
-        n, err := f.ResponseWriter.(io.ReaderFrom).ReadFrom(r)
-        f.written += n
-        return n, err
-}
-
-func sanitizeMethod(m string) string {
-        switch m {
-        case "GET", "get":
-                return "get"
-        case "PUT", "put":
-                return "put"
-        case "HEAD", "head":
-                return "head"
-        case "POST", "post":
-                return "post"
-        case "DELETE", "delete":
-                return "delete"
-        case "CONNECT", "connect":
-                return "connect"
-        case "OPTIONS", "options":
-                return "options"
-        case "NOTIFY", "notify":
-                return "notify"
-        default:
-                return strings.ToLower(m)
-        }
-}
-
-func sanitizeCode(s int) string {
-        switch s {
-        case 100:
-                return "100"
-        case 101:
-                return "101"
-
-        case 200:
-                return "200"
-        case 201:
-                return "201"
-        case 202:
-                return "202"
-        case 203:
-                return "203"
-        case 204:
-                return "204"
-        case 205:
-                return "205"
-        case 206:
-                return "206"
-
-        case 300:
-                return "300"
-        case 301:
-                return "301"
-        case 302:
-                return "302"
-        case 304:
-                return "304"
-        case 305:
-                return "305"
-        case 307:
-                return "307"
-
-        case 400:
-                return "400"
-        case 401:
-                return "401"
-        case 402:
-                return "402"
-        case 403:
-                return "403"
-        case 404:
-                return "404"
-        case 405:
-                return "405"
-        case 406:
-                return "406"
-        case 407:
-                return "407"
-        case 408:
-                return "408"
-        case 409:
-                return "409"
-        case 410:
-                return "410"
-        case 411:
-                return "411"
-        case 412:
-                return "412"
-        case 413:
-                return "413"
-        case 414:
-                return "414"
-        case 415:
-                return "415"
-        case 416:
-                return "416"
-        case 417:
-                return "417"
-        case 418:
-                return "418"
-
-        case 500:
-                return "500"
-        case 501:
-                return "501"
-        case 502:
-                return "502"
-        case 503:
-                return "503"
-        case 504:
-                return "504"
-        case 505:
-                return "505"
-
-        case 428:
-                return "428"
-        case 429:
-                return "429"
-        case 431:
-                return "431"
-        case 511:
-                return "511"
-
-        default:
-                return strconv.Itoa(s)
-        }
-}
-
-// gzipAccepted returns whether the client will accept gzip-encoded content.
-func gzipAccepted(header http.Header) bool {
-        a := header.Get(acceptEncodingHeader)
-        parts := strings.Split(a, ",")
-        for _, part := range parts {
-                part = strings.TrimSpace(part)
-                if part == "gzip" || strings.HasPrefix(part, "gzip;") {
-                        return true
-                }
-        }
-        return false
-}
-
-// httpError removes any content-encoding header and then calls http.Error with
-// the provided error and http.StatusInternalServerErrer. Error contents is
-// supposed to be uncompressed plain text. However, same as with a plain
-// http.Error, any header settings will be void if the header has already been
-// sent. The error message will still be written to the writer, but it will
-// probably be of limited use.
-func httpError(rsp http.ResponseWriter, err error) {
-        rsp.Header().Del(contentEncodingHeader)
-        http.Error(
-                rsp,
-                "An error has occurred while serving metrics:\n\n"+err.Error(),
-                http.StatusInternalServerError,
-        )
-}
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 55176d5..9b80979 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
@@ -16,8 +16,6 @@ package prometheus
 import (
         "errors"
         "os"
-
-        "github.com/prometheus/procfs"
 )
 
 type processCollector struct {
@@ -59,20 +57,9 @@ type ProcessCollectorOpts struct {
 // 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.
-//
-// 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{})
+// The collector only works on operating systems with a Linux-style proc
+// filesystem and on Microsoft Windows. On other operating systems, it will not
+// collect any metrics.
 func NewProcessCollector(opts ProcessCollectorOpts) Collector {
         ns := ""
         if len(opts.Namespace) > 0 {
@@ -126,7 +113,7 @@ func NewProcessCollector(opts ProcessCollectorOpts) Collector {
         }
 
         // Set up process metric collection if supported by the runtime.
-        if _, err := procfs.NewStat(); err == nil {
+        if canCollectProcess() {
                 c.collectFn = c.processCollect
         } else {
                 c.collectFn = func(ch chan<- Metric) {
@@ -153,46 +140,6 @@ func (c *processCollector) Collect(ch chan<- Metric) {
         c.collectFn(ch)
 }
 
-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
-        }
-
-        if stat, err := p.NewStat(); err == nil {
-                ch <- MustNewConstMetric(c.cpuTotal, CounterValue, stat.CPUTime())
-                ch <- MustNewConstMetric(c.vsize, GaugeValue, float64(stat.VirtualMemory()))
-                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
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go
new file mode 100644
index 0000000..3117461
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go
@@ -0,0 +1,65 @@
+// Copyright 2019 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.
+
+// +build !windows
+
+package prometheus
+
+import (
+        "github.com/prometheus/procfs"
+)
+
+func canCollectProcess() bool {
+        _, err := procfs.NewDefaultFS()
+        return err == nil
+}
+
+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
+        }
+
+        if stat, err := p.Stat(); err == nil {
+                ch <- MustNewConstMetric(c.cpuTotal, CounterValue, stat.CPUTime())
+                ch <- MustNewConstMetric(c.vsize, GaugeValue, float64(stat.VirtualMemory()))
+                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.Limits(); err == nil {
+                ch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(limits.OpenFiles))
+                ch <- MustNewConstMetric(c.maxVsize, GaugeValue, float64(limits.AddressSpace))
+        } else {
+                c.reportError(ch, nil, err)
+        }
+}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go
new file mode 100644
index 0000000..e0b935d
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go
@@ -0,0 +1,112 @@
+// Copyright 2019 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 (
+        "syscall"
+        "unsafe"
+
+        "golang.org/x/sys/windows"
+)
+
+func canCollectProcess() bool {
+        return true
+}
+
+var (
+        modpsapi    = syscall.NewLazyDLL("psapi.dll")
+        modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+        procGetProcessMemoryInfo  = modpsapi.NewProc("GetProcessMemoryInfo")
+        procGetProcessHandleCount = modkernel32.NewProc("GetProcessHandleCount")
+)
+
+type processMemoryCounters struct {
+        // https://docs.microsoft.com/en-us/windows/desktop/api/psapi/ns-psapi-_process_memory_counters_ex
+        _                          uint32
+        PageFaultCount             uint32
+        PeakWorkingSetSize         uint64
+        WorkingSetSize             uint64
+        QuotaPeakPagedPoolUsage    uint64
+        QuotaPagedPoolUsage        uint64
+        QuotaPeakNonPagedPoolUsage uint64
+        QuotaNonPagedPoolUsage     uint64
+        PagefileUsage              uint64
+        PeakPagefileUsage          uint64
+        PrivateUsage               uint64
+}
+
+func getProcessMemoryInfo(handle windows.Handle) (processMemoryCounters, error) {
+        mem := processMemoryCounters{}
+        r1, _, err := procGetProcessMemoryInfo.Call(
+                uintptr(handle),
+                uintptr(unsafe.Pointer(&mem)),
+                uintptr(unsafe.Sizeof(mem)),
+        )
+        if r1 != 1 {
+                return mem, err
+        } else {
+                return mem, nil
+        }
+}
+
+func getProcessHandleCount(handle windows.Handle) (uint32, error) {
+        var count uint32
+        r1, _, err := procGetProcessHandleCount.Call(
+                uintptr(handle),
+                uintptr(unsafe.Pointer(&count)),
+        )
+        if r1 != 1 {
+                return 0, err
+        } else {
+                return count, nil
+        }
+}
+
+func (c *processCollector) processCollect(ch chan<- Metric) {
+        h, err := windows.GetCurrentProcess()
+        if err != nil {
+                c.reportError(ch, nil, err)
+                return
+        }
+
+        var startTime, exitTime, kernelTime, userTime windows.Filetime
+        err = windows.GetProcessTimes(h, &startTime, &exitTime, &kernelTime, &userTime)
+        if err != nil {
+                c.reportError(ch, nil, err)
+                return
+        }
+        ch <- MustNewConstMetric(c.startTime, GaugeValue, float64(startTime.Nanoseconds()/1e9))
+        ch <- MustNewConstMetric(c.cpuTotal, CounterValue, fileTimeToSeconds(kernelTime)+fileTimeToSeconds(userTime))
+
+        mem, err := getProcessMemoryInfo(h)
+        if err != nil {
+                c.reportError(ch, nil, err)
+                return
+        }
+        ch <- MustNewConstMetric(c.vsize, GaugeValue, float64(mem.PrivateUsage))
+        ch <- MustNewConstMetric(c.rss, GaugeValue, float64(mem.WorkingSetSize))
+
+        handles, err := getProcessHandleCount(h)
+        if err != nil {
+                c.reportError(ch, nil, err)
+                return
+        }
+        ch <- MustNewConstMetric(c.openFDs, GaugeValue, float64(handles))
+        ch <- MustNewConstMetric(c.maxFDs, GaugeValue, float64(16*1024*1024)) // Windows has a hard-coded max limit, not per-process.
+}
+
+func fileTimeToSeconds(ft windows.Filetime) float64 {
+        return float64(uint64(ft.HighDateTime)<<32+uint64(ft.LowDateTime)) / 1e7
+}
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 67b56d3..fa53568 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go
@@ -38,7 +38,6 @@ type delegator interface {
 type responseWriterDelegator struct {
         http.ResponseWriter
 
-        handler, method    string
         status             int
         written            int64
         wroteHeader        bool
@@ -75,8 +74,11 @@ type closeNotifierDelegator struct{ *responseWriterDelegator }
 type flusherDelegator struct{ *responseWriterDelegator }
 type hijackerDelegator struct{ *responseWriterDelegator }
 type readerFromDelegator struct{ *responseWriterDelegator }
+type pusherDelegator struct{ *responseWriterDelegator }
 
 func (d closeNotifierDelegator) CloseNotify() <-chan bool {
+        //lint:ignore SA1019 http.CloseNotifier is deprecated but we don't want to
+        //remove support from client_golang yet.
         return d.ResponseWriter.(http.CloseNotifier).CloseNotify()
 }
 func (d flusherDelegator) Flush() {
@@ -93,6 +95,9 @@ func (d readerFromDelegator) ReadFrom(re io.Reader) (int64, error) {
         d.written += n
         return n, err
 }
+func (d pusherDelegator) Push(target string, opts *http.PushOptions) error {
+        return d.ResponseWriter.(http.Pusher).Push(target, opts)
+}
 
 var pickDelegator = make([]func(*responseWriterDelegator) delegator, 32)
 
@@ -196,4 +201,157 @@ func init() {
                         http.CloseNotifier
                 }{d, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
         }
+        pickDelegator[pusher] = func(d *responseWriterDelegator) delegator { // 16
+                return pusherDelegator{d}
+        }
+        pickDelegator[pusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 17
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        http.CloseNotifier
+                }{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}}
+        }
+        pickDelegator[pusher+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 19
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        http.Flusher
+                        http.CloseNotifier
+                }{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}}
+        }
+        pickDelegator[pusher+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 21
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        http.Hijacker
+                        http.CloseNotifier
+                }{d, pusherDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
+        }
+        pickDelegator[pusher+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 22
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        http.Hijacker
+                        http.Flusher
+                }{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
+        }
+        pickDelegator[pusher+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { //23
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        http.Hijacker
+                        http.Flusher
+                        http.CloseNotifier
+                }{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}}
+        }
+        pickDelegator[pusher+readerFrom+closeNotifier] = func(d *responseWriterDelegator) delegator { // 25
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.CloseNotifier
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, closeNotifierDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 26
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Flusher
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 27
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Flusher
+                        http.CloseNotifier
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 28
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Hijacker
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 29
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Hijacker
+                        http.CloseNotifier
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 30
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Hijacker
+                        http.Flusher
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
+        }
+        pickDelegator[pusher+readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 31
+                return struct {
+                        *responseWriterDelegator
+                        http.Pusher
+                        io.ReaderFrom
+                        http.Hijacker
+                        http.Flusher
+                        http.CloseNotifier
+                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
+        }
+}
+
+func newDelegator(w http.ResponseWriter, observeWriteHeaderFunc func(int)) delegator {
+        d := &responseWriterDelegator{
+                ResponseWriter:     w,
+                observeWriteHeader: observeWriteHeaderFunc,
+        }
+
+        id := 0
+        //lint:ignore SA1019 http.CloseNotifier is deprecated but we don't want to
+        //remove support from client_golang yet.
+        if _, ok := w.(http.CloseNotifier); ok {
+                id += closeNotifier
+        }
+        if _, ok := w.(http.Flusher); ok {
+                id += flusher
+        }
+        if _, ok := w.(http.Hijacker); ok {
+                id += hijacker
+        }
+        if _, ok := w.(io.ReaderFrom); ok {
+                id += readerFrom
+        }
+        if _, ok := w.(http.Pusher); ok {
+                id += pusher
+        }
+
+        return pickDelegator[id](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
deleted file mode 100644
index 31a7069..0000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_1_8.go
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.8
-
-package promhttp
-
-import (
-        "io"
-        "net/http"
-)
-
-type pusherDelegator struct{ *responseWriterDelegator }
-
-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}
-        }
-        pickDelegator[pusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 17
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        http.CloseNotifier
-                }{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}}
-        }
-        pickDelegator[pusher+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 19
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        http.Flusher
-                        http.CloseNotifier
-                }{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}}
-        }
-        pickDelegator[pusher+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 21
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        http.Hijacker
-                        http.CloseNotifier
-                }{d, pusherDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
-        }
-        pickDelegator[pusher+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 22
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        http.Hijacker
-                        http.Flusher
-                }{d, pusherDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
-        }
-        pickDelegator[pusher+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { //23
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        http.Hijacker
-                        http.Flusher
-                        http.CloseNotifier
-                }{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}}
-        }
-        pickDelegator[pusher+readerFrom+closeNotifier] = func(d *responseWriterDelegator) delegator { // 25
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.CloseNotifier
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, closeNotifierDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+flusher] = func(d *responseWriterDelegator) delegator { // 26
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Flusher
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 27
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Flusher
-                        http.CloseNotifier
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+hijacker] = func(d *responseWriterDelegator) delegator { // 28
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Hijacker
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+hijacker+closeNotifier] = func(d *responseWriterDelegator) delegator { // 29
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Hijacker
-                        http.CloseNotifier
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, closeNotifierDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+hijacker+flusher] = func(d *responseWriterDelegator) delegator { // 30
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Hijacker
-                        http.Flusher
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}}
-        }
-        pickDelegator[pusher+readerFrom+hijacker+flusher+closeNotifier] = func(d *responseWriterDelegator) delegator { // 31
-                return struct {
-                        *responseWriterDelegator
-                        http.Pusher
-                        io.ReaderFrom
-                        http.Hijacker
-                        http.Flusher
-                        http.CloseNotifier
-                }{d, pusherDelegator{d}, readerFromDelegator{d}, hijackerDelegator{d}, flusherDelegator{d}, closeNotifierDelegator{d}}
-        }
-}
-
-func newDelegator(w http.ResponseWriter, observeWriteHeaderFunc func(int)) delegator {
-        d := &responseWriterDelegator{
-                ResponseWriter:     w,
-                observeWriteHeader: observeWriteHeaderFunc,
-        }
-
-        id := 0
-        if _, ok := w.(http.CloseNotifier); ok {
-                id += closeNotifier
-        }
-        if _, ok := w.(http.Flusher); ok {
-                id += flusher
-        }
-        if _, ok := w.(http.Hijacker); ok {
-                id += hijacker
-        }
-        if _, ok := w.(io.ReaderFrom); ok {
-                id += readerFrom
-        }
-        if _, ok := w.(http.Pusher); ok {
-                id += pusher
-        }
-
-        return pickDelegator[id](d)
-}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_pre_1_8.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_pre_1_8.go
deleted file mode 100644
index 8bb9b8b..0000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator_pre_1_8.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2017 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.
-
-// +build !go1.8
-
-package promhttp
-
-import (
-        "io"
-        "net/http"
-)
-
-func newDelegator(w http.ResponseWriter, observeWriteHeaderFunc func(int)) delegator {
-        d := &responseWriterDelegator{
-                ResponseWriter:     w,
-                observeWriteHeader: observeWriteHeaderFunc,
-        }
-
-        id := 0
-        if _, ok := w.(http.CloseNotifier); ok {
-                id += closeNotifier
-        }
-        if _, ok := w.(http.Flusher); ok {
-                id += flusher
-        }
-        if _, ok := w.(http.Hijacker); ok {
-                id += hijacker
-        }
-        if _, ok := w.(io.ReaderFrom); ok {
-                id += readerFrom
-        }
-
-        return pickDelegator[id](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 668eb6b..cea5a90 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
@@ -47,7 +47,6 @@ import (
 
 const (
         contentTypeHeader     = "Content-Type"
-        contentLengthHeader   = "Content-Length"
         contentEncodingHeader = "Content-Encoding"
         acceptEncodingHeader  = "Accept-Encoding"
 )
@@ -85,10 +84,32 @@ func Handler() http.Handler {
 // instrumentation. Use the InstrumentMetricHandler function to apply the same
 // kind of instrumentation as it is used by the Handler function.
 func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
-        var inFlightSem chan struct{}
+        var (
+                inFlightSem chan struct{}
+                errCnt      = prometheus.NewCounterVec(
+                        prometheus.CounterOpts{
+                                Name: "promhttp_metric_handler_errors_total",
+                                Help: "Total number of internal errors encountered by the promhttp metric handler.",
+                        },
+                        []string{"cause"},
+                )
+        )
+
         if opts.MaxRequestsInFlight > 0 {
                 inFlightSem = make(chan struct{}, opts.MaxRequestsInFlight)
         }
+        if opts.Registry != nil {
+                // Initialize all possibilites that can occur below.
+                errCnt.WithLabelValues("gathering")
+                errCnt.WithLabelValues("encoding")
+                if err := opts.Registry.Register(errCnt); err != nil {
+                        if are, ok := err.(prometheus.AlreadyRegisteredError); ok {
+                                errCnt = are.ExistingCollector.(*prometheus.CounterVec)
+                        } else {
+                                panic(err)
+                        }
+                }
+        }
 
         h := http.HandlerFunc(func(rsp http.ResponseWriter, req *http.Request) {
                 if inFlightSem != nil {
@@ -107,6 +128,7 @@ func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
                         if opts.ErrorLog != nil {
                                 opts.ErrorLog.Println("error gathering metrics:", err)
                         }
+                        errCnt.WithLabelValues("gathering").Inc()
                         switch opts.ErrorHandling {
                         case PanicOnError:
                                 panic(err)
@@ -147,6 +169,7 @@ func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
                                 if opts.ErrorLog != nil {
                                         opts.ErrorLog.Println("error encoding and sending metric family:", err)
                                 }
+                                errCnt.WithLabelValues("encoding").Inc()
                                 switch opts.ErrorHandling {
                                 case PanicOnError:
                                         panic(err)
@@ -237,9 +260,12 @@ const (
         // Ignore errors and try to serve as many metrics as possible.  However,
         // if no metrics can be served, serve an HTTP status code 500 and the
         // last error message in the body. Only use this in deliberate "best
-        // effort" metrics collection scenarios. It is recommended to at least
-        // log errors (by providing an ErrorLog in HandlerOpts) to not mask
-        // errors completely.
+        // effort" metrics collection scenarios. In this case, it is highly
+        // recommended to provide other means of detecting errors: By setting an
+        // ErrorLog in HandlerOpts, the errors are logged. By providing a
+        // Registry in HandlerOpts, the exposed metrics include an error counter
+        // "promhttp_metric_handler_errors_total", which can be used for
+        // alerts.
         ContinueOnError
         // Panic upon the first error encountered (useful for "crash only" apps).
         PanicOnError
@@ -262,6 +288,18 @@ type HandlerOpts struct {
         // logged regardless of the configured ErrorHandling provided ErrorLog
         // is not nil.
         ErrorHandling HandlerErrorHandling
+        // If Registry is not nil, it is used to register a metric
+        // "promhttp_metric_handler_errors_total", partitioned by "cause". A
+        // failed registration causes a panic. Note that this error counter is
+        // different from the instrumentation you get from the various
+        // InstrumentHandler... helpers. It counts errors that don't necessarily
+        // result in a non-2xx HTTP status code. There are two typical cases:
+        // (1) Encoding errors that only happen after streaming of the HTTP body
+        // has already started (and the status code 200 has been sent). This
+        // should only happen with custom collectors. (2) Collection errors with
+        // no effect on the HTTP status code because ErrorHandling is set to
+        // ContinueOnError.
+        Registry prometheus.Registerer
         // If DisableCompression is true, the handler will never compress the
         // response, even if requested by the client.
         DisableCompression bool
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
index 86fd564..83c49b6 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
@@ -14,7 +14,9 @@
 package promhttp
 
 import (
+        "crypto/tls"
         "net/http"
+        "net/http/httptrace"
         "time"
 
         "github.com/prometheus/client_golang/prometheus"
@@ -95,3 +97,123 @@ func InstrumentRoundTripperDuration(obs prometheus.ObserverVec, next http.RoundT
                 return resp, err
         })
 }
+
+// InstrumentTrace is used to offer flexibility in instrumenting the available
+// httptrace.ClientTrace hook functions. Each function is passed a float64
+// representing the time in seconds since the start of the http request. A user
+// may choose to use separately buckets Histograms, or implement custom
+// instance labels on a per function basis.
+type InstrumentTrace struct {
+        GotConn              func(float64)
+        PutIdleConn          func(float64)
+        GotFirstResponseByte func(float64)
+        Got100Continue       func(float64)
+        DNSStart             func(float64)
+        DNSDone              func(float64)
+        ConnectStart         func(float64)
+        ConnectDone          func(float64)
+        TLSHandshakeStart    func(float64)
+        TLSHandshakeDone     func(float64)
+        WroteHeaders         func(float64)
+        Wait100Continue      func(float64)
+        WroteRequest         func(float64)
+}
+
+// InstrumentRoundTripperTrace is a middleware that wraps the provided
+// RoundTripper and reports times to hook functions provided in the
+// InstrumentTrace struct. Hook functions that are not present in the provided
+// InstrumentTrace struct are ignored. Times reported to the hook functions are
+// time since the start of the request. Only with Go1.9+, those times are
+// guaranteed to never be negative. (Earlier Go versions are not using a
+// monotonic clock.) Note that partitioning of Histograms is expensive and
+// should be used judiciously.
+//
+// For hook functions that receive an error as an argument, no observations are
+// made in the event of a non-nil error value.
+//
+// See the example for ExampleInstrumentRoundTripperDuration for example usage.
+func InstrumentRoundTripperTrace(it *InstrumentTrace, next http.RoundTripper) RoundTripperFunc {
+        return RoundTripperFunc(func(r *http.Request) (*http.Response, error) {
+                start := time.Now()
+
+                trace := &httptrace.ClientTrace{
+                        GotConn: func(_ httptrace.GotConnInfo) {
+                                if it.GotConn != nil {
+                                        it.GotConn(time.Since(start).Seconds())
+                                }
+                        },
+                        PutIdleConn: func(err error) {
+                                if err != nil {
+                                        return
+                                }
+                                if it.PutIdleConn != nil {
+                                        it.PutIdleConn(time.Since(start).Seconds())
+                                }
+                        },
+                        DNSStart: func(_ httptrace.DNSStartInfo) {
+                                if it.DNSStart != nil {
+                                        it.DNSStart(time.Since(start).Seconds())
+                                }
+                        },
+                        DNSDone: func(_ httptrace.DNSDoneInfo) {
+                                if it.DNSDone != nil {
+                                        it.DNSDone(time.Since(start).Seconds())
+                                }
+                        },
+                        ConnectStart: func(_, _ string) {
+                                if it.ConnectStart != nil {
+                                        it.ConnectStart(time.Since(start).Seconds())
+                                }
+                        },
+                        ConnectDone: func(_, _ string, err error) {
+                                if err != nil {
+                                        return
+                                }
+                                if it.ConnectDone != nil {
+                                        it.ConnectDone(time.Since(start).Seconds())
+                                }
+                        },
+                        GotFirstResponseByte: func() {
+                                if it.GotFirstResponseByte != nil {
+                                        it.GotFirstResponseByte(time.Since(start).Seconds())
+                                }
+                        },
+                        Got100Continue: func() {
+                                if it.Got100Continue != nil {
+                                        it.Got100Continue(time.Since(start).Seconds())
+                                }
+                        },
+                        TLSHandshakeStart: func() {
+                                if it.TLSHandshakeStart != nil {
+                                        it.TLSHandshakeStart(time.Since(start).Seconds())
+                                }
+                        },
+                        TLSHandshakeDone: func(_ tls.ConnectionState, err error) {
+                                if err != nil {
+                                        return
+                                }
+                                if it.TLSHandshakeDone != nil {
+                                        it.TLSHandshakeDone(time.Since(start).Seconds())
+                                }
+                        },
+                        WroteHeaders: func() {
+                                if it.WroteHeaders != nil {
+                                        it.WroteHeaders(time.Since(start).Seconds())
+                                }
+                        },
+                        Wait100Continue: func() {
+                                if it.Wait100Continue != nil {
+                                        it.Wait100Continue(time.Since(start).Seconds())
+                                }
+                        },
+                        WroteRequest: func(_ httptrace.WroteRequestInfo) {
+                                if it.WroteRequest != nil {
+                                        it.WroteRequest(time.Since(start).Seconds())
+                                }
+                        },
+                }
+                r = r.WithContext(httptrace.WithClientTrace(r.Context(), trace))
+
+                return next.RoundTrip(r)
+        })
+}
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
deleted file mode 100644
index a034d1e..0000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client_1_8.go
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.8
-
-package promhttp
-
-import (
-        "context"
-        "crypto/tls"
-        "net/http"
-        "net/http/httptrace"
-        "time"
-)
-
-// InstrumentTrace is used to offer flexibility in instrumenting the available
-// httptrace.ClientTrace hook functions. Each function is passed a float64
-// representing the time in seconds since the start of the http request. A user
-// may choose to use separately buckets Histograms, or implement custom
-// instance labels on a per function basis.
-type InstrumentTrace struct {
-        GotConn              func(float64)
-        PutIdleConn          func(float64)
-        GotFirstResponseByte func(float64)
-        Got100Continue       func(float64)
-        DNSStart             func(float64)
-        DNSDone              func(float64)
-        ConnectStart         func(float64)
-        ConnectDone          func(float64)
-        TLSHandshakeStart    func(float64)
-        TLSHandshakeDone     func(float64)
-        WroteHeaders         func(float64)
-        Wait100Continue      func(float64)
-        WroteRequest         func(float64)
-}
-
-// InstrumentRoundTripperTrace is a middleware that wraps the provided
-// RoundTripper and reports times to hook functions provided in the
-// InstrumentTrace struct. Hook functions that are not present in the provided
-// InstrumentTrace struct are ignored. Times reported to the hook functions are
-// time since the start of the request. Only with Go1.9+, those times are
-// guaranteed to never be negative. (Earlier Go versions are not using a
-// monotonic clock.) Note that partitioning of Histograms is expensive and
-// should be used judiciously.
-//
-// For hook functions that receive an error as an argument, no observations are
-// made in the event of a non-nil error value.
-//
-// See the example for ExampleInstrumentRoundTripperDuration for example usage.
-func InstrumentRoundTripperTrace(it *InstrumentTrace, next http.RoundTripper) RoundTripperFunc {
-        return RoundTripperFunc(func(r *http.Request) (*http.Response, error) {
-                start := time.Now()
-
-                trace := &httptrace.ClientTrace{
-                        GotConn: func(_ httptrace.GotConnInfo) {
-                                if it.GotConn != nil {
-                                        it.GotConn(time.Since(start).Seconds())
-                                }
-                        },
-                        PutIdleConn: func(err error) {
-                                if err != nil {
-                                        return
-                                }
-                                if it.PutIdleConn != nil {
-                                        it.PutIdleConn(time.Since(start).Seconds())
-                                }
-                        },
-                        DNSStart: func(_ httptrace.DNSStartInfo) {
-                                if it.DNSStart != nil {
-                                        it.DNSStart(time.Since(start).Seconds())
-                                }
-                        },
-                        DNSDone: func(_ httptrace.DNSDoneInfo) {
-                                if it.DNSDone != nil {
-                                        it.DNSDone(time.Since(start).Seconds())
-                                }
-                        },
-                        ConnectStart: func(_, _ string) {
-                                if it.ConnectStart != nil {
-                                        it.ConnectStart(time.Since(start).Seconds())
-                                }
-                        },
-                        ConnectDone: func(_, _ string, err error) {
-                                if err != nil {
-                                        return
-                                }
-                                if it.ConnectDone != nil {
-                                        it.ConnectDone(time.Since(start).Seconds())
-                                }
-                        },
-                        GotFirstResponseByte: func() {
-                                if it.GotFirstResponseByte != nil {
-                                        it.GotFirstResponseByte(time.Since(start).Seconds())
-                                }
-                        },
-                        Got100Continue: func() {
-                                if it.Got100Continue != nil {
-                                        it.Got100Continue(time.Since(start).Seconds())
-                                }
-                        },
-                        TLSHandshakeStart: func() {
-                                if it.TLSHandshakeStart != nil {
-                                        it.TLSHandshakeStart(time.Since(start).Seconds())
-                                }
-                        },
-                        TLSHandshakeDone: func(_ tls.ConnectionState, err error) {
-                                if err != nil {
-                                        return
-                                }
-                                if it.TLSHandshakeDone != nil {
-                                        it.TLSHandshakeDone(time.Since(start).Seconds())
-                                }
-                        },
-                        WroteHeaders: func() {
-                                if it.WroteHeaders != nil {
-                                        it.WroteHeaders(time.Since(start).Seconds())
-                                }
-                        },
-                        Wait100Continue: func() {
-                                if it.Wait100Continue != nil {
-                                        it.Wait100Continue(time.Since(start).Seconds())
-                                }
-                        },
-                        WroteRequest: func(_ httptrace.WroteRequestInfo) {
-                                if it.WroteRequest != nil {
-                                        it.WroteRequest(time.Since(start).Seconds())
-                                }
-                        },
-                }
-                r = r.WithContext(httptrace.WithClientTrace(context.Background(), trace))
-
-                return next.RoundTrip(r)
-        })
-}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/registry.go b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
index b5e70b9..6c32516 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/registry.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
@@ -325,9 +325,17 @@ func (r *Registry) Register(c Collector) error {
                 return nil
         }
         if existing, exists := r.collectorsByID[collectorID]; exists {
-                return AlreadyRegisteredError{
-                        ExistingCollector: existing,
-                        NewCollector:      c,
+                switch e := existing.(type) {
+                case *wrappingCollector:
+                        return AlreadyRegisteredError{
+                                ExistingCollector: e.unwrapRecursively(),
+                                NewCollector:      c,
+                        }
+                default:
+                        return AlreadyRegisteredError{
+                                ExistingCollector: e,
+                                NewCollector:      c,
+                        }
                 }
         }
         // If the collectorID is new, but at least one of the descs existed
@@ -680,7 +688,7 @@ func processMetric(
 // Gatherers is a slice of Gatherer instances that implements the Gatherer
 // interface itself. Its Gather method calls Gather on all Gatherers in the
 // slice in order and returns the merged results. Errors returned from the
-// Gather calles are all returned in a flattened MultiError. Duplicate and
+// Gather calls are all returned in a flattened MultiError. Duplicate and
 // inconsistent Metrics are skipped (first occurrence in slice order wins) and
 // reported in the returned error.
 //
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/summary.go b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
index 2980614..c970fde 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/summary.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
@@ -16,8 +16,10 @@ package prometheus
 import (
         "fmt"
         "math"
+        "runtime"
         "sort"
         "sync"
+        "sync/atomic"
         "time"
 
         "github.com/beorn7/perks/quantile"
@@ -37,7 +39,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 estimations at all by
+// upcoming v1.0.0 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.
 //
@@ -56,16 +58,8 @@ type Summary interface {
         Observe(float64)
 }
 
-// DefObjectives are the default Summary quantile values.
-//
-// Deprecated: DefObjectives will not be used as the default objectives in
-// v0.10 of the library. The default Summary will have no quantiles then.
-var (
-        DefObjectives = map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}
-
-        errQuantileLabelNotAllowed = fmt.Errorf(
-                "%q is not allowed as label name in summaries", quantileLabel,
-        )
+var errQuantileLabelNotAllowed = fmt.Errorf(
+        "%q is not allowed as label name in summaries", quantileLabel,
 )
 
 // Default values for SummaryOpts.
@@ -84,7 +78,7 @@ const (
 // 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.
+// as the default value will change in the upcoming v1.0.0 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
@@ -121,13 +115,8 @@ type SummaryOpts struct {
         // Objectives defines the quantile rank estimates with their respective
         // absolute error. If Objectives[q] = e, then the value reported for q
         // will be the φ-quantile value for some φ between q-e and q+e.  The
-        // default value is DefObjectives. It is used if Objectives is left at
-        // its zero value (i.e. nil). To create a Summary without Objectives,
-        // set it to an empty map (i.e. map[float64]float64{}).
-        //
-        // Deprecated: Note that the current value of DefObjectives is
-        // deprecated. It will be replaced by an empty map in v0.10 of the
-        // library. Please explicitly set Objectives to the desired value.
+        // default value is an empty map, resulting in a summary without
+        // quantiles.
         Objectives map[float64]float64
 
         // MaxAge defines the duration for which an observation stays relevant
@@ -151,7 +140,7 @@ type SummaryOpts struct {
         BufCap uint32
 }
 
-// Great fuck-up with the sliding-window decay algorithm... The Merge method of
+// Problem with the sliding-window decay algorithm... The Merge method of
 // perk/quantile is actually not working as advertised - and it might be
 // unfixable, as the underlying algorithm is apparently not capable of merging
 // summaries in the first place. To avoid using Merge, we are currently adding
@@ -196,7 +185,7 @@ func newSummary(desc *Desc, opts SummaryOpts, labelValues ...string) Summary {
         }
 
         if opts.Objectives == nil {
-                opts.Objectives = DefObjectives
+                opts.Objectives = map[float64]float64{}
         }
 
         if opts.MaxAge < 0 {
@@ -214,6 +203,17 @@ func newSummary(desc *Desc, opts SummaryOpts, labelValues ...string) Summary {
                 opts.BufCap = DefBufCap
         }
 
+        if len(opts.Objectives) == 0 {
+                // Use the lock-free implementation of a Summary without objectives.
+                s := &noObjectivesSummary{
+                        desc:       desc,
+                        labelPairs: makeLabelPairs(desc, labelValues),
+                        counts:     [2]*summaryCounts{&summaryCounts{}, &summaryCounts{}},
+                }
+                s.init(s) // Init self-collection.
+                return s
+        }
+
         s := &summary{
                 desc: desc,
 
@@ -382,6 +382,116 @@ func (s *summary) swapBufs(now time.Time) {
         }
 }
 
+type summaryCounts 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
+}
+
+type noObjectivesSummary struct {
+        // countAndHotIdx enables lock-free writes with use of atomic updates.
+        // The most significant bit is the hot index [0 or 1] of the count field
+        // below. Observe calls update the hot one. All remaining bits count the
+        // number of Observe calls. Observe starts by incrementing this counter,
+        // and finish by incrementing the count field in the respective
+        // summaryCounts, as a marker for completion.
+        //
+        // Calls of the Write method (which are non-mutating reads from the
+        // perspective of the summary) swap the hot–cold under the writeMtx
+        // lock. A cooldown is awaited (while locked) by comparing the number of
+        // observations with the initiation count. Once they match, then the
+        // last observation on the now cool one has completed. All cool fields must
+        // be merged into the new hot before releasing writeMtx.
+
+        // Fields with atomic access first! See alignment constraint:
+        // http://golang.org/pkg/sync/atomic/#pkg-note-BUG
+        countAndHotIdx uint64
+
+        selfCollector
+        desc     *Desc
+        writeMtx sync.Mutex // Only used in the Write method.
+
+        // Two counts, one is "hot" for lock-free observations, the other is
+        // "cold" for writing out a dto.Metric. It has to be an array of
+        // pointers to guarantee 64bit alignment of the histogramCounts, see
+        // http://golang.org/pkg/sync/atomic/#pkg-note-BUG.
+        counts [2]*summaryCounts
+
+        labelPairs []*dto.LabelPair
+}
+
+func (s *noObjectivesSummary) Desc() *Desc {
+        return s.desc
+}
+
+func (s *noObjectivesSummary) Observe(v float64) {
+        // We increment h.countAndHotIdx so that the counter in the lower
+        // 63 bits gets incremented. At the same time, we get the new value
+        // back, which we can use to find the currently-hot counts.
+        n := atomic.AddUint64(&s.countAndHotIdx, 1)
+        hotCounts := s.counts[n>>63]
+
+        for {
+                oldBits := atomic.LoadUint64(&hotCounts.sumBits)
+                newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
+                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 (s *noObjectivesSummary) Write(out *dto.Metric) error {
+        // For simplicity, we protect this whole method by a mutex. 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, if possible at
+        // all.
+        s.writeMtx.Lock()
+        defer s.writeMtx.Unlock()
+
+        // Adding 1<<63 switches the hot index (from 0 to 1 or from 1 to 0)
+        // without touching the count bits. See the struct comments for a full
+        // description of the algorithm.
+        n := atomic.AddUint64(&s.countAndHotIdx, 1<<63)
+        // count is contained unchanged in the lower 63 bits.
+        count := n & ((1 << 63) - 1)
+        // The most significant bit tells us which counts is hot. The complement
+        // is thus the cold one.
+        hotCounts := s.counts[n>>63]
+        coldCounts := s.counts[(^n)>>63]
+
+        // Await cooldown.
+        for count != atomic.LoadUint64(&coldCounts.count) {
+                runtime.Gosched() // Let observations get work done.
+        }
+
+        sum := &dto.Summary{
+                SampleCount: proto.Uint64(count),
+                SampleSum:   proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),
+        }
+
+        out.Summary = sum
+        out.Label = s.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) + sum.GetSampleSum())
+                if atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {
+                        atomic.StoreUint64(&coldCounts.sumBits, 0)
+                        break
+                }
+        }
+        return nil
+}
+
 type quantSort []*dto.Quantile
 
 func (s quantSort) Len() int {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/wrap.go b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
index 49159bf..e303eef 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
@@ -32,6 +32,12 @@ import (
 // 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.
 //
+// Conflicts between Collectors registered through the original Registerer with
+// Collectors registered through the wrapping Registerer will still be
+// detected. Any AlreadyRegisteredError returned by the Register method of
+// either Registerer will contain the ExistingCollector in the form it was
+// provided to the respective registry.
+//
 // The Collector example demonstrates a use of WrapRegistererWith.
 func WrapRegistererWith(labels Labels, reg Registerer) Registerer {
         return &wrappingRegisterer{
@@ -54,6 +60,12 @@ func WrapRegistererWith(labels Labels, reg Registerer) Registerer {
 // (see NewGoCollector) and the process collector (see NewProcessCollector). (In
 // fact, those metrics are already prefixed with “go_” or “process_”,
 // respectively.)
+//
+// Conflicts between Collectors registered through the original Registerer with
+// Collectors registered through the wrapping Registerer will still be
+// detected. Any AlreadyRegisteredError returned by the Register method of
+// either Registerer will contain the ExistingCollector in the form it was
+// provided to the respective registry.
 func WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer {
         return &wrappingRegisterer{
                 wrappedRegisterer: reg,
@@ -123,6 +135,15 @@ func (c *wrappingCollector) Describe(ch chan<- *Desc) {
         }
 }
 
+func (c *wrappingCollector) unwrapRecursively() Collector {
+        switch wc := c.wrappedCollector.(type) {
+        case *wrappingCollector:
+                return wc.unwrapRecursively()
+        default:
+                return wc
+        }
+}
+
 type wrappingMetric struct {
         wrappedMetric Metric
         prefix        string
diff --git a/vendor/github.com/prometheus/common/model/time.go b/vendor/github.com/prometheus/common/model/time.go
index 46259b1..7b0064f 100644
--- a/vendor/github.com/prometheus/common/model/time.go
+++ b/vendor/github.com/prometheus/common/model/time.go
@@ -150,7 +150,13 @@ func (t *Time) UnmarshalJSON(b []byte) error {
                         return err
                 }
 
-                *t = Time(v + va)
+                // If the value was something like -0.1 the negative is lost in the
+                // parsing because of the leading zero, this ensures that we capture it.
+                if len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 {
+                        *t = Time(v+va) * -1
+                } else {
+                        *t = Time(v + va)
+                }
 
         default:
                 return fmt.Errorf("invalid time %q", string(b))
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 0227700..4204734 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -33,13 +33,13 @@ github.com/mdlayher/netlink/nlenc
 # github.com/mdlayher/wifi v0.0.0-20180727163819-efdf3f4195d9
 github.com/mdlayher/wifi
 github.com/mdlayher/wifi/internal/nl80211
-# github.com/prometheus/client_golang v0.9.2
+# github.com/prometheus/client_golang v1.0.0
 github.com/prometheus/client_golang/prometheus
 github.com/prometheus/client_golang/prometheus/promhttp
 github.com/prometheus/client_golang/prometheus/internal
 # github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90
 github.com/prometheus/client_model/go
-# github.com/prometheus/common v0.3.0
+# github.com/prometheus/common v0.4.1
 github.com/prometheus/common/log
 github.com/prometheus/common/version
 github.com/prometheus/common/expfmt
@@ -72,8 +72,8 @@ golang.org/x/net/internal/socket
 golang.org/x/sync/errgroup
 # golang.org/x/sys v0.0.0-20190610081024-1e42afee0f76
 golang.org/x/sys/unix
-golang.org/x/sys/windows/svc/eventlog
 golang.org/x/sys/windows
+golang.org/x/sys/windows/svc/eventlog
 golang.org/x/sys/windows/registry
 # gopkg.in/alecthomas/kingpin.v2 v2.2.6
 gopkg.in/alecthomas/kingpin.v2