@@ -149,11 +149,11 @@ github.com/coreos/pkg                               3ac0863d7acf3bc44daf49afef89

 code.cloudfoundry.org/clock                         02e53af36e6c978af692887ed449b74026d76fec # v1.0.0

 # prometheus

-github.com/prometheus/client_golang                 c42bebe5a5cddfc6b28cd639103369d8a75dfa89 # v1.3.0

+github.com/prometheus/client_golang                 6edbbd9e560190e318cdc5b4d3e630b442858380 # v1.6.0

 github.com/beorn7/perks                             37c8de3658fcb183f997c4e13e8337516ab753e6 # v1.0.1

-github.com/prometheus/client_model                  d1d2010b5beead3fa1c5f271a5cf626e40b3ad6e # v0.1.0

-github.com/prometheus/common                        287d3e634a1e550c9e463dd7e5a75a422c614505 # v0.7.0

-github.com/prometheus/procfs                        6d489fc7f1d9cd890a250f3ea3431b1744b9623f # v0.0.8

+github.com/prometheus/client_model                  7bc5445566f0fe75b15de23e6b93886e982d7bf9 # v0.2.0

+github.com/prometheus/common                        d978bcb1309602d68bb4ba69cf3f8ed900e07308 # v0.9.1

+github.com/prometheus/procfs                        46159f73e74d1cb8dc223deef9b2d049286f46b1 # v0.0.11

 github.com/matttproud/golang_protobuf_extensions    c12348ce28de40eed0136aa2b644d0ee0650e56c # v1.0.1

 github.com/pkg/errors                               614d223910a179a466c1767a985424175c39b465 # v0.9.1

 github.com/grpc-ecosystem/go-grpc-prometheus        c225b8c3b01faf2899099b768856a9e916e5087b # v1.2.0

@@ -3,12 +3,16 @@ module github.com/prometheus/client_golang

 require (

 	github.com/beorn7/perks v1.0.1

 	github.com/cespare/xxhash/v2 v2.1.1

-	github.com/golang/protobuf v1.3.2

-	github.com/json-iterator/go v1.1.8

-	github.com/prometheus/client_model v0.1.0

-	github.com/prometheus/common v0.7.0

-	github.com/prometheus/procfs v0.0.8

-	golang.org/x/sys v0.0.0-20191220142924-d4481acd189f

+	github.com/golang/protobuf v1.4.0

+	github.com/json-iterator/go v1.1.9

+	github.com/kr/pretty v0.1.0 // indirect

+	github.com/prometheus/client_model v0.2.0

+	github.com/prometheus/common v0.9.1

+	github.com/prometheus/procfs v0.0.11

+	github.com/stretchr/testify v1.4.0 // indirect

+	golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f

+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect

+	gopkg.in/yaml.v2 v2.2.5 // indirect

 )

 go 1.11

@@ -17,6 +17,7 @@ import (

 	"errors"

 	"math"

 	"sync/atomic"

+	"time"

 	dto "github.com/prometheus/client_model/go"

 )

@@ -42,11 +43,27 @@ type Counter interface {

 	Add(float64)

 }

+// ExemplarAdder is implemented by Counters that offer the option of adding a

+// value to the Counter together with an exemplar. Its AddWithExemplar method

+// works like the Add method of the Counter interface but also replaces the

+// currently saved exemplar (if any) with a new one, created from the provided

+// value, the current time as timestamp, and the provided labels. Empty Labels

+// will lead to a valid (label-less) exemplar. But if Labels is nil, the current

+// exemplar is left in place. AddWithExemplar panics if the value is < 0, if any

+// of the provided labels are invalid, or if the provided labels contain more

+// than 64 runes in total.

+type ExemplarAdder interface {

+	AddWithExemplar(value float64, exemplar Labels)

+}

+

 // CounterOpts is an alias for Opts. See there for doc comments.

 type CounterOpts Opts

 // NewCounter creates a new Counter based on the provided CounterOpts.

 //

+// The returned implementation also implements ExemplarAdder. It is safe to

+// perform the corresponding type assertion.

+//

 // The returned implementation tracks the counter value in two separate

 // variables, a float64 and a uint64. The latter is used to track calls of the

 // Inc method and calls of the Add method with a value that can be represented

@@ -61,7 +78,7 @@ func NewCounter(opts CounterOpts) Counter {

 		nil,

 		opts.ConstLabels,

 	)

-	result := &counter{desc: desc, labelPairs: desc.constLabelPairs}

+	result := &counter{desc: desc, labelPairs: desc.constLabelPairs, now: time.Now}

 	result.init(result) // Init self-collection.

 	return result

 }

@@ -78,6 +95,9 @@ type counter struct {

 	desc *Desc

 	labelPairs []*dto.LabelPair

+	exemplar   atomic.Value // Containing nil or a *dto.Exemplar.

+

+	now func() time.Time // To mock out time.Now() for testing.

 }

 func (c *counter) Desc() *Desc {

@@ -88,6 +108,7 @@ func (c *counter) Add(v float64) {

 	if v < 0 {

 		panic(errors.New("counter cannot decrease in value"))

 	}

+

 	ival := uint64(v)

 	if float64(ival) == v {

 		atomic.AddUint64(&c.valInt, ival)

@@ -103,6 +124,11 @@ func (c *counter) Add(v float64) {

 	}

 }

+func (c *counter) AddWithExemplar(v float64, e Labels) {

+	c.Add(v)

+	c.updateExemplar(v, e)

+}

+

 func (c *counter) Inc() {

 	atomic.AddUint64(&c.valInt, 1)

 }

@@ -112,7 +138,23 @@ func (c *counter) Write(out *dto.Metric) error {

 	ival := atomic.LoadUint64(&c.valInt)

 	val := fval + float64(ival)

-	return populateMetric(CounterValue, val, c.labelPairs, out)

+	var exemplar *dto.Exemplar

+	if e := c.exemplar.Load(); e != nil {

+		exemplar = e.(*dto.Exemplar)

+	}

+

+	return populateMetric(CounterValue, val, c.labelPairs, exemplar, out)

+}

+

+func (c *counter) updateExemplar(v float64, l Labels) {

+	if l == nil {

+		return

+	}

+	e, err := newExemplar(v, c.now(), l)

+	if err != nil {

+		panic(err)

+	}

+	c.exemplar.Store(e)

 }

 // CounterVec is a Collector that bundles a set of Counters that all share the

@@ -138,7 +180,7 @@ func NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec {

 			if len(lvs) != len(desc.variableLabels) {

 				panic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, lvs))

 			}

-			result := &counter{desc: desc, labelPairs: makeLabelPairs(desc, lvs)}

+			result := &counter{desc: desc, labelPairs: makeLabelPairs(desc, lvs), now: time.Now}

 			result.init(result) // Init self-collection.

 			return result

 		}),

@@ -267,6 +309,8 @@ type CounterFunc interface {

 // provided function must be concurrency-safe. The function should also honor

 // the contract for a Counter (values only go up, not down), but compliance will

 // not be checked.

+//

+// Check out the ExampleGaugeFunc examples for the similar GaugeFunc.

 func NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc {

 	return newValueFunc(NewDesc(

 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),

@@ -84,25 +84,21 @@

 // of those four metric types can be found in the Prometheus docs:

 // https://prometheus.io/docs/concepts/metric_types/

 //

-// A fifth "type" of metric is Untyped. It behaves like a Gauge, but signals the

-// Prometheus server not to assume anything about its type.

-//

-// In addition to the fundamental metric types Gauge, Counter, Summary,

-// Histogram, and Untyped, a very important part of the Prometheus data model is

-// the partitioning of samples along dimensions called labels, which results in

+// In addition to the fundamental metric types Gauge, Counter, Summary, and

+// Histogram, a very important part of the Prometheus data model is the

+// partitioning of samples along dimensions called labels, which results in

 // metric vectors. The fundamental types are GaugeVec, CounterVec, SummaryVec,

-// HistogramVec, and UntypedVec.

+// and HistogramVec.

 //

 // While only the fundamental metric types implement the Metric interface, both

 // the metrics and their vector versions implement the Collector interface. A

 // Collector manages the collection of a number of Metrics, but for convenience,

-// a Metric can also “collect itself”. Note that Gauge, Counter, Summary,

-// Histogram, and Untyped are interfaces themselves while GaugeVec, CounterVec,

-// SummaryVec, HistogramVec, and UntypedVec are not.

+// a Metric can also “collect itself”. Note that Gauge, Counter, Summary, and

+// Histogram are interfaces themselves while GaugeVec, CounterVec, SummaryVec,

+// and HistogramVec are not.

 //

 // To create instances of Metrics and their vector versions, you need a suitable

-// …Opts struct, i.e. GaugeOpts, CounterOpts, SummaryOpts, HistogramOpts, or

-// UntypedOpts.

+// …Opts struct, i.e. GaugeOpts, CounterOpts, SummaryOpts, or HistogramOpts.

 //

 // Custom Collectors and constant Metrics

 //

@@ -118,13 +114,16 @@

 // existing numbers into Prometheus Metrics during collection. An own

 // implementation of the Collector interface is perfect for that. You can create

 // Metric instances “on the fly” using NewConstMetric, NewConstHistogram, and

-// NewConstSummary (and their respective Must… versions). That will happen in

-// the Collect method. The Describe method has to return separate Desc

-// instances, representative of the “throw-away” metrics to be created later.

-// NewDesc comes in handy to create those Desc instances. Alternatively, you

-// 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

+// NewConstSummary (and their respective Must… versions). NewConstMetric is used

+// for all metric types with just a float64 as their value: Counter, Gauge, and

+// a special “type” called Untyped. Use the latter if you are not sure if the

+// mirrored metric is a Counter or a Gauge. Creation of the Metric instance

+// happens in the Collect method. The Describe method has to return separate

+// Desc instances, representative of the “throw-away” metrics to be created

+// later.  NewDesc comes in handy to create those Desc instances. Alternatively,

+// you 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

@@ -123,7 +123,7 @@ func (g *gauge) Sub(val float64) {

 func (g *gauge) Write(out *dto.Metric) error {

 	val := math.Float64frombits(atomic.LoadUint64(&g.valBits))

-	return populateMetric(GaugeValue, val, g.labelPairs, out)

+	return populateMetric(GaugeValue, val, g.labelPairs, nil, out)

 }

 // GaugeVec is a Collector that bundles a set of Gauges that all share the same

@@ -73,7 +73,7 @@ func NewGoCollector() Collector {

 			nil, nil),

 		gcDesc: NewDesc(

 			"go_gc_duration_seconds",

-			"A summary of the GC invocation durations.",

+			"A summary of the pause duration of garbage collection cycles.",

 			nil, nil),

 		goInfoDesc: NewDesc(

 			"go_info",

@@ -20,6 +20,7 @@ import (

 	"sort"

 	"sync"

 	"sync/atomic"

+	"time"

 	"github.com/golang/protobuf/proto"

@@ -151,6 +152,10 @@ type HistogramOpts struct {

 // NewHistogram creates a new Histogram based on the provided HistogramOpts. It

 // panics if the buckets in HistogramOpts are not in strictly increasing order.

+//

+// The returned implementation also implements ExemplarObserver. It is safe to

+// perform the corresponding type assertion. Exemplars are tracked separately

+// for each bucket.

 func NewHistogram(opts HistogramOpts) Histogram {

 	return newHistogram(

 		NewDesc(

@@ -188,6 +193,7 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr

 		upperBounds: opts.Buckets,

 		labelPairs:  makeLabelPairs(desc, labelValues),

 		counts:      [2]*histogramCounts{{}, {}},

+		now:         time.Now,

 	}

 	for i, upperBound := range h.upperBounds {

 		if i < len(h.upperBounds)-1 {

@@ -205,9 +211,10 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr

 		}

 	}

 	// Finally we know the final length of h.upperBounds and can make buckets

-	// for both counts:

+	// for both counts as well as exemplars:

 	h.counts[0].buckets = make([]uint64, len(h.upperBounds))

 	h.counts[1].buckets = make([]uint64, len(h.upperBounds))

+	h.exemplars = make([]atomic.Value, len(h.upperBounds)+1)

 	h.init(h) // Init self-collection.

 	return h

@@ -254,6 +261,9 @@ type histogram struct {

 	upperBounds []float64

 	labelPairs  []*dto.LabelPair

+	exemplars   []atomic.Value // One more than buckets (to include +Inf), each a *dto.Exemplar.

+

+	now func() time.Time // To mock out time.Now() for testing.

 }

 func (h *histogram) Desc() *Desc {

@@ -261,36 +271,13 @@ func (h *histogram) Desc() *Desc {

 }

 func (h *histogram) Observe(v float64) {

-	// TODO(beorn7): For small numbers of buckets (<30), a linear search is

-	// slightly faster than the binary search. If we really care, we could

-	// switch from one search strategy to the other depending on the number

-	// of buckets.

-	//

-	// Microbenchmarks (BenchmarkHistogramNoLabels):

-	// 11 buckets: 38.3 ns/op linear - binary 48.7 ns/op

-	// 100 buckets: 78.1 ns/op linear - binary 54.9 ns/op

-	// 300 buckets: 154 ns/op linear - binary 61.6 ns/op

-	i := sort.SearchFloat64s(h.upperBounds, v)

-

-	// 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, 1)

-	hotCounts := h.counts[n>>63]

+	h.observe(v, h.findBucket(v))

+}

-	if i < len(h.upperBounds) {

-		atomic.AddUint64(&hotCounts.buckets[i], 1)

-	}

-	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 (h *histogram) ObserveWithExemplar(v float64, e Labels) {

+	i := h.findBucket(v)

+	h.observe(v, i)

+	h.updateExemplar(v, i, e)

 }

 func (h *histogram) Write(out *dto.Metric) error {

@@ -329,6 +316,18 @@ func (h *histogram) Write(out *dto.Metric) error {

 			CumulativeCount: proto.Uint64(cumCount),

 			UpperBound:      proto.Float64(upperBound),

 		}

+		if e := h.exemplars[i].Load(); e != nil {

+			his.Bucket[i].Exemplar = e.(*dto.Exemplar)

+		}

+	}

+	// If there is an exemplar for the +Inf bucket, we have to add that bucket explicitly.

+	if e := h.exemplars[len(h.upperBounds)].Load(); e != nil {

+		b := &dto.Bucket{

+			CumulativeCount: proto.Uint64(count),

+			UpperBound:      proto.Float64(math.Inf(1)),

+			Exemplar:        e.(*dto.Exemplar),

+		}

+		his.Bucket = append(his.Bucket, b)

 	}

 	out.Histogram = his

@@ -352,6 +351,57 @@ func (h *histogram) Write(out *dto.Metric) error {

 	return nil

 }

+// findBucket returns the index of the bucket for the provided value, or

+// len(h.upperBounds) for the +Inf bucket.

+func (h *histogram) findBucket(v float64) int {

+	// TODO(beorn7): For small numbers of buckets (<30), a linear search is

+	// slightly faster than the binary search. If we really care, we could

+	// switch from one search strategy to the other depending on the number

+	// of buckets.

+	//

+	// Microbenchmarks (BenchmarkHistogramNoLabels):

+	// 11 buckets: 38.3 ns/op linear - binary 48.7 ns/op

+	// 100 buckets: 78.1 ns/op linear - binary 54.9 ns/op

+	// 300 buckets: 154 ns/op linear - binary 61.6 ns/op

+	return sort.SearchFloat64s(h.upperBounds, v)

+}

+

+// observe is the implementation for Observe without the findBucket part.

+func (h *histogram) observe(v float64, bucket int) {

+	// 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, 1)

+	hotCounts := h.counts[n>>63]

+

+	if bucket < len(h.upperBounds) {

+		atomic.AddUint64(&hotCounts.buckets[bucket], 1)

+	}

+	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)

+}

+

+// updateExemplar replaces the exemplar for the provided bucket. With empty

+// labels, it's a no-op. It panics if any of the labels is invalid.

+func (h *histogram) updateExemplar(v float64, bucket int, l Labels) {

+	if l == nil {

+		return

+	}

+	e, err := newExemplar(v, h.now(), l)

+	if err != nil {

+		panic(err)

+	}

+	h.exemplars[bucket].Store(e)

+}

+

 // HistogramVec is a Collector that bundles a set of Histograms that all share the

 // same Desc, but have different values for their variable labels. This is used

 // if you want to count the same thing partitioned by various dimensions

@@ -50,3 +50,15 @@ type ObserverVec interface {

 	Collector

 }

+

+// ExemplarObserver is implemented by Observers that offer the option of

+// observing a value together with an exemplar. Its ObserveWithExemplar method

+// works like the Observe method of an Observer but also replaces the currently

+// saved exemplar (if any) with a new one, created from the provided value, the

+// current time as timestamp, and the provided Labels. Empty Labels will lead to

+// a valid (label-less) exemplar. But if Labels is nil, the current exemplar is

+// left in place. ObserveWithExemplar panics if any of the provided labels are

+// invalid or if the provided labels contain more than 64 runes in total.

+type ExemplarObserver interface {

+	ObserveWithExemplar(value float64, exemplar Labels)

+}

@@ -33,18 +33,22 @@ var (

 )

 type processMemoryCounters struct {

-	// https://docs.microsoft.com/en-us/windows/desktop/api/psapi/ns-psapi-_process_memory_counters_ex

+	// System interface description

+	// https://docs.microsoft.com/en-us/windows/desktop/api/psapi/ns-psapi-process_memory_counters_ex

+

+	// Refer to the Golang internal implementation

+	// https://golang.org/src/internal/syscall/windows/psapi_windows.go

 	_                          uint32

 	PageFaultCount             uint32

-	PeakWorkingSetSize         uint64

-	WorkingSetSize             uint64

-	QuotaPeakPagedPoolUsage    uint64

-	QuotaPagedPoolUsage        uint64

-	QuotaPeakNonPagedPoolUsage uint64

-	QuotaNonPagedPoolUsage     uint64

-	PagefileUsage              uint64

-	PeakPagefileUsage          uint64

-	PrivateUsage               uint64

+	PeakWorkingSetSize         uintptr

+	WorkingSetSize             uintptr

+	QuotaPeakPagedPoolUsage    uintptr

+	QuotaPagedPoolUsage        uintptr

+	QuotaPeakNonPagedPoolUsage uintptr

+	QuotaNonPagedPoolUsage     uintptr

+	PagefileUsage              uintptr

+	PeakPagefileUsage          uintptr

+	PrivateUsage               uintptr

 }

 func getProcessMemoryInfo(handle windows.Handle) (processMemoryCounters, error) {

@@ -53,12 +53,16 @@ func (r *responseWriterDelegator) Written() int64 {

 }

 func (r *responseWriterDelegator) WriteHeader(code int) {

+	if r.observeWriteHeader != nil && !r.wroteHeader {

+		// Only call observeWriteHeader for the 1st time. It's a bug if

+		// WriteHeader is called more than once, but we want to protect

+		// against it here. Note that we still delegate the WriteHeader

+		// to the original ResponseWriter to not mask the bug from it.

+		r.observeWriteHeader(code)

+	}

 	r.status = code

 	r.wroteHeader = true

 	r.ResponseWriter.WriteHeader(code)

-	if r.observeWriteHeader != nil {

-		r.observeWriteHeader(code)

-	}

 }

 func (r *responseWriterDelegator) Write(b []byte) (int, error) {

@@ -144,7 +144,12 @@ func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {

 			}

 		}

-		contentType := expfmt.Negotiate(req.Header)

+		var contentType expfmt.Format

+		if opts.EnableOpenMetrics {

+			contentType = expfmt.NegotiateIncludingOpenMetrics(req.Header)

+		} else {

+			contentType = expfmt.Negotiate(req.Header)

+		}

 		header := rsp.Header()

 		header.Set(contentTypeHeader, string(contentType))

@@ -162,28 +167,40 @@ func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {

 		enc := expfmt.NewEncoder(w, contentType)

-		var lastErr error

-		for _, mf := range mfs {

-			if err := enc.Encode(mf); err != nil {

-				lastErr = err

-				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)

-				case ContinueOnError:

-					// Handled later.

-				case HTTPErrorOnError:

-					httpError(rsp, err)

-					return

-				}

+		// handleError handles the error according to opts.ErrorHandling

+		// and returns true if we have to abort after the handling.

+		handleError := func(err error) bool {

+			if err == nil {

+				return false

+			}

+			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)

+			case HTTPErrorOnError:

+				// We cannot really send an HTTP error at this

+				// point because we most likely have written

+				// something to rsp already. But at least we can

+				// stop sending.

+				return true

 			}

+			// Do nothing in all other cases, including ContinueOnError.

+			return false

 		}

-		if lastErr != nil {

-			httpError(rsp, lastErr)

+		for _, mf := range mfs {

+			if handleError(enc.Encode(mf)) {

+				return

+			}

+		}

+		if closer, ok := enc.(expfmt.Closer); ok {

+			// This in particular takes care of the final "# EOF\n" line for OpenMetrics.

+			if handleError(closer.Close()) {

+				return

+			}

 		}

 	})

@@ -255,7 +272,12 @@ type HandlerErrorHandling int

 // errors are encountered.

 const (

 	// Serve an HTTP status code 500 upon the first error

-	// encountered. Report the error message in the body.

+	// encountered. Report the error message in the body. Note that HTTP

+	// errors cannot be served anymore once the beginning of a regular

+	// payload has been sent. Thus, in the (unlikely) case that encoding the

+	// payload into the negotiated wire format fails, serving the response

+	// will simply be aborted. Set an ErrorLog in HandlerOpts to detect

+	// those errors.

 	HTTPErrorOnError HandlerErrorHandling = iota

 	// 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

@@ -318,6 +340,16 @@ type HandlerOpts struct {

 	// away). Until the implementation is improved, it is recommended to

 	// implement a separate timeout in potentially slow Collectors.

 	Timeout time.Duration

+	// If true, the experimental OpenMetrics encoding is added to the

+	// possible options during content negotiation. Note that Prometheus

+	// 2.5.0+ will negotiate OpenMetrics as first priority. OpenMetrics is

+	// the only way to transmit exemplars. However, the move to OpenMetrics

+	// is not completely transparent. Most notably, the values of "quantile"

+	// labels of Summaries and "le" labels of Histograms are formatted with

+	// a trailing ".0" if they would otherwise look like integer numbers

+	// (which changes the identity of the resulting series on the Prometheus

+	// server).

+	EnableOpenMetrics bool

 }

 // gzipAccepted returns whether the client will accept gzip-encoded content.

@@ -334,11 +366,9 @@ func gzipAccepted(header http.Header) bool {

 }

 // 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.

+// the provided error and http.StatusInternalServerError. Error contents is

+// supposed to be uncompressed plain text. Same as with a plain http.Error, this

+// must not be called if the header or any payload has already been sent.

 func httpError(rsp http.ResponseWriter, err error) {

 	rsp.Header().Del(contentEncodingHeader)

 	http.Error(

@@ -16,8 +16,11 @@ package prometheus

 import (

 	"fmt"

 	"sort"

+	"time"

+	"unicode/utf8"

 	"github.com/golang/protobuf/proto"

+	"github.com/golang/protobuf/ptypes"

 	dto "github.com/prometheus/client_model/go"

 )

@@ -25,7 +28,8 @@ import (

 // ValueType is an enumeration of metric types that represent a simple value.

 type ValueType int

-// Possible values for the ValueType enum.

+// Possible values for the ValueType enum. Use UntypedValue to mark a metric

+// with an unknown type.

 const (

 	_ ValueType = iota

 	CounterValue

@@ -69,7 +73,7 @@ func (v *valueFunc) Desc() *Desc {

 }

 func (v *valueFunc) Write(out *dto.Metric) error {

-	return populateMetric(v.valType, v.function(), v.labelPairs, out)

+	return populateMetric(v.valType, v.function(), v.labelPairs, nil, out)

 }

 // NewConstMetric returns a metric with one fixed value that cannot be

@@ -116,19 +120,20 @@ func (m *constMetric) Desc() *Desc {

 }

 func (m *constMetric) Write(out *dto.Metric) error {

-	return populateMetric(m.valType, m.val, m.labelPairs, out)

+	return populateMetric(m.valType, m.val, m.labelPairs, nil, out)

 }

 func populateMetric(

 	t ValueType,

 	v float64,

 	labelPairs []*dto.LabelPair,

+	e *dto.Exemplar,

 	m *dto.Metric,

 ) error {

 	m.Label = labelPairs

 	switch t {

 	case CounterValue:

-		m.Counter = &dto.Counter{Value: proto.Float64(v)}

+		m.Counter = &dto.Counter{Value: proto.Float64(v), Exemplar: e}

 	case GaugeValue:

 		m.Gauge = &dto.Gauge{Value: proto.Float64(v)}

 	case UntypedValue:

@@ -160,3 +165,40 @@ func makeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair {

 	sort.Sort(labelPairSorter(labelPairs))

 	return labelPairs

 }

+

+// ExemplarMaxRunes is the max total number of runes allowed in exemplar labels.

+const ExemplarMaxRunes = 64

+

+// newExemplar creates a new dto.Exemplar from the provided values. An error is

+// returned if any of the label names or values are invalid or if the total

+// number of runes in the label names and values exceeds ExemplarMaxRunes.

+func newExemplar(value float64, ts time.Time, l Labels) (*dto.Exemplar, error) {

+	e := &dto.Exemplar{}

+	e.Value = proto.Float64(value)

+	tsProto, err := ptypes.TimestampProto(ts)

+	if err != nil {

+		return nil, err

+	}

+	e.Timestamp = tsProto

+	labelPairs := make([]*dto.LabelPair, 0, len(l))

+	var runes int

+	for name, value := range l {

+		if !checkLabelName(name) {

+			return nil, fmt.Errorf("exemplar label name %q is invalid", name)

+		}

+		runes += utf8.RuneCountInString(name)

+		if !utf8.ValidString(value) {

+			return nil, fmt.Errorf("exemplar label value %q is not valid UTF-8", value)

+		}

+		runes += utf8.RuneCountInString(value)

+		labelPairs = append(labelPairs, &dto.LabelPair{

+			Name:  proto.String(name),

+			Value: proto.String(value),

+		})

+	}

+	if runes > ExemplarMaxRunes {

+		return nil, fmt.Errorf("exemplar labels have %d runes, exceeding the limit of %d", runes, ExemplarMaxRunes)

+	}

+	e.Label = labelPairs

+	return e, nil

+}

@@ -91,6 +91,18 @@ func (m *metricVec) Delete(labels Labels) bool {

 	return m.metricMap.deleteByHashWithLabels(h, labels, m.curry)

 }

+// Without explicit forwarding of Describe, Collect, Reset, those methods won't

+// show up in GoDoc.

+

+// Describe implements Collector.

+func (m *metricVec) Describe(ch chan<- *Desc) { m.metricMap.Describe(ch) }

+

+// Collect implements Collector.

+func (m *metricVec) Collect(ch chan<- Metric) { m.metricMap.Collect(ch) }

+

+// Reset deletes all metrics in this vector.

+func (m *metricVec) Reset() { m.metricMap.Reset() }

+

 func (m *metricVec) curryWith(labels Labels) (*metricVec, error) {

 	var (

 		newCurry []curriedLabelValue

@@ -1,11 +1,14 @@

 // Code generated by protoc-gen-go. DO NOT EDIT.

 // source: metrics.proto

-package io_prometheus_client // import "github.com/prometheus/client_model/go"

+package io_prometheus_client

-import proto "github.com/golang/protobuf/proto"

-import fmt "fmt"

-import math "math"

+import (

+	fmt "fmt"

+	proto "github.com/golang/protobuf/proto"

+	timestamp "github.com/golang/protobuf/ptypes/timestamp"

+	math "math"

+)

 // Reference imports to suppress errors if they are not otherwise used.

 var _ = proto.Marshal

@@ -16,7 +19,7 @@ var _ = math.Inf

 // is compatible with the proto package it is being compiled against.

 // A compilation error at this line likely means your copy of the

 // proto package needs to be updated.

-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

 type MetricType int32

@@ -35,6 +38,7 @@ var MetricType_name = map[int32]string{

 	3: "UNTYPED",

 	4: "HISTOGRAM",

 }

+

 var MetricType_value = map[string]int32{

 	"COUNTER":   0,

 	"GAUGE":     1,

@@ -48,9 +52,11 @@ func (x MetricType) Enum() *MetricType {

 	*p = x

 	return p

 }

+

 func (x MetricType) String() string {

 	return proto.EnumName(MetricType_name, int32(x))

 }

+

 func (x *MetricType) UnmarshalJSON(data []byte) error {

 	value, err := proto.UnmarshalJSONEnum(MetricType_value, data, "MetricType")

 	if err != nil {

@@ -59,8 +65,9 @@ func (x *MetricType) UnmarshalJSON(data []byte) error {

 	*x = MetricType(value)

 	return nil

 }

+

 func (MetricType) EnumDescriptor() ([]byte, []int) {

-	return fileDescriptor_metrics_c97c9a2b9560cb8f, []int{0}

+	return fileDescriptor_6039342a2ba47b72, []int{0}

 }

 type LabelPair struct {

@@ -75,16 +82,17 @@ func (m *LabelPair) Reset()         { *m = LabelPair{} }

 func (m *LabelPair) String() string { return proto.CompactTextString(m) }

 func (*LabelPair) ProtoMessage()    {}

 func (*LabelPair) Descriptor() ([]byte, []int) {

-	return fileDescriptor_metrics_c97c9a2b9560cb8f, []int{0}

+	return fileDescriptor_6039342a2ba47b72, []int{0}

 }

+

 func (m *LabelPair) XXX_Unmarshal(b []byte) error {

 	return xxx_messageInfo_LabelPair.Unmarshal(m, b)

 }

 func (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

 	return xxx_messageInfo_LabelPair.Marshal(b, m, deterministic)

 }

-func (dst *LabelPair) XXX_Merge(src proto.Message) {

-	xxx_messageInfo_LabelPair.Merge(dst, src)

+func (m *LabelPair) XXX_Merge(src proto.Message) {

+	xxx_messageInfo_LabelPair.Merge(m, src)

 }

 func (m *LabelPair) XXX_Size() int {

 	return xxx_messageInfo_LabelPair.Size(m)

@@ -120,16 +128,17 @@ func (m *Gauge) Reset()         { *m = Gauge{} }

 func (m *Gauge) String() string { return proto.CompactTextString(m) }

 func (*Gauge) ProtoMessage()    {}

 func (*Gauge) Descriptor() ([]byte, []int) {

-	return fileDescriptor_metrics_c97c9a2b9560cb8f, []int{1}

+	return fileDescriptor_6039342a2ba47b72, []int{1}

 }

+

 func (m *Gauge) XXX_Unmarshal(b []byte) error {

 	return xxx_messageInfo_Gauge.Unmarshal(m, b)

 }

 func (m *Gauge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

 	return xxx_messageInfo_Gauge.Marshal(b, m, deterministic)

 }

-func (dst *Gauge) XXX_Merge(src proto.Message) {

-	xxx_messageInfo_Gauge.Merge(dst, src)

+func (m *Gauge) XXX_Merge(src proto.Message) {

+	xxx_messageInfo_Gauge.Merge(m, src)

 }

 func (m *Gauge) XXX_Size() int {

 	return xxx_messageInfo_Gauge.Size(m)

@@ -148,26 +157,28 @@ func (m *Gauge) GetValue() float64 {

 }

 type Counter struct {

-	Value                *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`

-	XXX_NoUnkeyedLiteral struct{} `json:"-"`

-	XXX_unrecognized     []byte   `json:"-"`

-	XXX_sizecache        int32    `json:"-"`

+	Value                *float64  `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`

+	Exemplar             *Exemplar `protobuf:"bytes,2,opt,name=exemplar" json:"exemplar,omitempty"`

+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`

+	XXX_unrecognized     []byte    `json:"-"`

+	XXX_sizecache        int32     `json:"-"`

 }

 func (m *Counter) Reset()         { *m = Counter{} }

 func (m *Counter) String() string { return proto.CompactTextString(m) }

 func (*Counter) ProtoMessage()    {}

 func (*Counter) Descriptor() ([]byte, []int) {

-	return fileDescriptor_metrics_c97c9a2b9560cb8f, []int{2}

+	return fileDescriptor_6039342a2ba47b72, []int{2}

 }

+

 func (m *Counter) XXX_Unmarshal(b []byte) error {

 	return xxx_messageInfo_Counter.Unmarshal(m, b)

 }

 func (m *Counter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

 	return xxx_messageInfo_Counter.Marshal(b, m, deterministic)

 }

-func (dst *Counter) XXX_Merge(src proto.Message) {

-	xxx_messageInfo_Counter.Merge(dst, src)

+func (m *Counter) XXX_Merge(src proto.Message) {

+	xxx_messageInfo_Counter.Merge(m, src)

 }

 func (m *Counter) XXX_Size() int {

 	return xxx_messageInfo_Counter.Size(m)

@@ -185,6 +196,13 @@ func (m *Counter) GetValue() float64 {

 	return 0

 }

+func (m *Counter) GetExemplar() *Exemplar {

+	if m != nil {

+		return m.Exemplar

+	}

+	return nil

+}

+

 type Quantile struct {

 	Quantile             *float64 `protobuf:"fixed64,1,opt,name=quantile" json:"quantile,omitempty"`

 	Value                *float64 `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"`

@@ -197,16 +215,17 @@ func (m *Quantile) Reset()         { *m = Quantile{} }

 func (m *Quantile) String() string { return proto.CompactTextString(m) }

 func (*Quantile) ProtoMessage()    {}

 func (*Quantile) Descriptor() ([]byte, []int) {

-	return fileDescriptor_metrics_c97c9a2b9560cb8f, []int{3}

+	return fileDescriptor_6039342a2ba47b72, []int{3}

 }

+

 func (m *Quantile) XXX_Unmarshal(b []byte) error {

 	return xxx_messageInfo_Quantile.Unmarshal(m, b)

 }

 func (m *Quantile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

 	return xxx_messageInfo_Quantile.Marshal(b, m, deterministic)

 }