package prometheus

Import Path
	github.com/prometheus/client_golang/prometheus (on go.dev)

Dependency Relation
	imports 27 packages, and imported by 24 packages

Involved Source Files

	    build_info_collector.go
	    collector.go
	    collectorfunc.go
	    counter.go
	    desc.go
	  d doc.go
		Package prometheus is the core instrumentation package. It provides metrics
		primitives to instrument code for monitoring. It also offers a registry for
		metrics. Sub-packages allow to expose the registered metrics via HTTP
		(package promhttp) or push them to a Pushgateway (package push). There is
		also a sub-package promauto, which provides metrics constructors with
		automatic registration.
		
		All exported functions and methods are safe to be used concurrently unless
		specified otherwise.
		
		# A Basic Example
		
		As a starting point, a very basic usage example:
		
			package main
		
			import (
				"log"
				"net/http"
		
				"github.com/prometheus/client_golang/prometheus"
				"github.com/prometheus/client_golang/prometheus/promhttp"
			)
		
			type metrics struct {
				cpuTemp  prometheus.Gauge
				hdFailures *prometheus.CounterVec
			}
		
			func NewMetrics(reg prometheus.Registerer) *metrics {
				m := &metrics{
					cpuTemp: prometheus.NewGauge(prometheus.GaugeOpts{
						Name: "cpu_temperature_celsius",
						Help: "Current temperature of the CPU.",
					}),
					hdFailures: prometheus.NewCounterVec(
						prometheus.CounterOpts{
							Name: "hd_errors_total",
							Help: "Number of hard-disk errors.",
						},
						[]string{"device"},
					),
				}
				reg.MustRegister(m.cpuTemp)
				reg.MustRegister(m.hdFailures)
				return m
			}
		
			func main() {
				// Create a non-global registry.
				reg := prometheus.NewRegistry()
		
				// Create new metrics and register them using the custom registry.
				m := NewMetrics(reg)
				// Set values for the new created metrics.
				m.cpuTemp.Set(65.3)
				m.hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
		
				// Expose metrics and custom registry via an HTTP server
				// using the HandleFor function. "/metrics" is the usual endpoint for that.
				http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))
				log.Fatal(http.ListenAndServe(":8080", nil))
			}
		
		This is a complete program that exports two metrics, a Gauge and a Counter,
		the latter with a label attached to turn it into a (one-dimensional) vector.
		It register the metrics using a custom registry and exposes them via an HTTP server
		on the /metrics endpoint.
		
		# Metrics
		
		The number of exported identifiers in this package might appear a bit
		overwhelming. However, in addition to the basic plumbing shown in the example
		above, you only need to understand the different metric types and their
		vector versions for basic usage. Furthermore, if you are not concerned with
		fine-grained control of when and how to register metrics with the registry,
		have a look at the promauto package, which will effectively allow you to
		ignore registration altogether in simple cases.
		
		Above, you have already touched the Counter and the Gauge. There are two more
		advanced metric types: the Summary and Histogram. A more thorough description
		of those four metric types can be found in the Prometheus docs:
		https://prometheus.io/docs/concepts/metric_types/
		
		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,
		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, 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, or HistogramOpts.
		
		# Custom Collectors and constant Metrics
		
		While you could create your own implementations of Metric, most likely you
		will only ever implement the Collector interface on your own. At a first
		glance, a custom Collector seems handy to bundle Metrics for common
		registration (with the prime example of the different metric vectors above,
		which bundle all the metrics of the same name but with different labels).
		
		There is a more involved use case, too: If you already have metrics
		available, created outside of the Prometheus context, you don't need the
		interface of the various Metric types. You essentially want to mirror the
		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). 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
		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.
		
		The Collector example illustrates the use case. You can also look at the
		source code of the processCollector (mirroring process metrics), the
		goCollector (mirroring Go metrics), or the expvarCollector (mirroring expvar
		metrics) as examples that are used in this package itself.
		
		If you just need to call a function to get a single float value to collect as
		a metric, GaugeFunc, CounterFunc, or UntypedFunc might be interesting
		shortcuts.
		
		# Advanced Uses of the Registry
		
		While MustRegister is the by far most common way of registering a Collector,
		sometimes you might want to handle the errors the registration might cause.
		As suggested by the name, MustRegister panics if an error occurs. With the
		Register function, the error is returned and can be handled.
		
		An error is returned if the registered Collector is incompatible or
		inconsistent with already registered metrics. The registry aims for
		consistency of the collected metrics according to the Prometheus data model.
		Inconsistencies are ideally detected at registration time, not at collect
		time. The former will usually be detected at start-up time of a program,
		while the latter will only happen at scrape time, possibly not even on the
		first scrape if the inconsistency only becomes relevant later. That is the
		main reason why a Collector and a Metric have to describe themselves to the
		registry.
		
		So far, everything we did operated on the so-called default registry, as it
		can be found in the global DefaultRegisterer variable. With NewRegistry, you
		can create a custom registry, or you can even implement the Registerer or
		Gatherer interfaces yourself. The methods Register and Unregister work in the
		same way on a custom registry as the global functions Register and Unregister
		on the default registry.
		
		There are a number of uses for custom registries: You can use registries with
		special properties, see NewPedanticRegistry. You can avoid global state, as
		it is imposed by the DefaultRegisterer. You can use multiple registries at
		the same time to expose different metrics in different ways.  You can use
		separate registries for testing purposes.
		
		Also note that the DefaultRegisterer comes registered with a Collector for Go
		runtime metrics (via NewGoCollector) and a Collector for process metrics (via
		NewProcessCollector). With a custom registry, you are in control and decide
		yourself about the Collectors to register.
		
		# HTTP Exposition
		
		The Registry implements the Gatherer interface. The caller of the Gather
		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.
		
		# Pushing to the Pushgateway
		
		Function for pushing to the Pushgateway can be found in the push sub-package.
		
		# Graphite Bridge
		
		Functions and examples to push metrics from a Gatherer to Graphite can be
		found in the graphite sub-package.
		
		# Other Means of Exposition
		
		More ways of exposing metrics can easily be added by following the approaches
		of the existing implementations.

	    expvar_collector.go
	    fnv.go
	    gauge.go
	    get_pid.go
	    go_collector.go
	    go_collector_latest.go
	    histogram.go
	    labels.go
	    metric.go
	    num_threads.go
	    observer.go
	    process_collector.go
	    process_collector_procfsenabled.go
	    registry.go
	    summary.go
	    timer.go
	    untyped.go
	    value.go
	    vec.go
	    vnext.go
	    wrap.go
Code Examples

	Collector
		package main
		
		import (
			"log"
			"net/http"
		
			"github.com/prometheus/client_golang/prometheus"
			"github.com/prometheus/client_golang/prometheus/promhttp"
		)
		
		// ClusterManager is an example for a system that might have been built without
		// Prometheus in mind. It models a central manager of jobs running in a
		// cluster. Thus, we implement a custom Collector called
		// ClusterManagerCollector, which collects information from a ClusterManager
		// using its provided methods and turns them into Prometheus Metrics for
		// collection.
		//
		// An additional challenge is that multiple instances of the ClusterManager are
		// run within the same binary, each in charge of a different zone. We need to
		// make use of wrapping Registerers to be able to register each
		// ClusterManagerCollector instance with Prometheus.
		type ClusterManager struct {
			Zone string
			// Contains many more fields not listed in this example.
		}
		
		// ReallyExpensiveAssessmentOfTheSystemState is a mock for the data gathering a
		// real cluster manager would have to do. Since it may actually be really
		// expensive, it must only be called once per collection. This implementation,
		// obviously, only returns some made-up data.
		func (c *ClusterManager) ReallyExpensiveAssessmentOfTheSystemState() (
			oomCountByHost map[string]int, ramUsageByHost map[string]float64,
		) {
			// Just example fake data.
			oomCountByHost = map[string]int{
				"foo.example.org": 42,
				"bar.example.org": 2001,
			}
			ramUsageByHost = map[string]float64{
				"foo.example.org": 6.023e23,
				"bar.example.org": 3.14,
			}
			return
		}
		
		// ClusterManagerCollector implements the Collector interface.
		type ClusterManagerCollector struct {
			ClusterManager *ClusterManager
		}
		
		// Descriptors used by the ClusterManagerCollector below.
		var (
			oomCountDesc = prometheus.NewDesc(
				"clustermanager_oom_crashes_total",
				"Number of OOM crashes.",
				[]string{"host"}, nil,
			)
			ramUsageDesc = prometheus.NewDesc(
				"clustermanager_ram_usage_bytes",
				"RAM usage as reported to the cluster manager.",
				[]string{"host"}, nil,
			)
		)
		
		// Describe is implemented with DescribeByCollect. That's possible because the
		// Collect method will always return the same two metrics with the same two
		// descriptors.
		func (cc ClusterManagerCollector) Describe(ch chan<- *prometheus.Desc) {
			prometheus.DescribeByCollect(cc, ch)
		}
		
		// Collect first triggers the ReallyExpensiveAssessmentOfTheSystemState. Then it
		// creates constant metrics for each host on the fly based on the returned data.
		//
		// Note that Collect could be called concurrently, so we depend on
		// ReallyExpensiveAssessmentOfTheSystemState to be concurrency-safe.
		func (cc ClusterManagerCollector) Collect(ch chan<- prometheus.Metric) {
			oomCountByHost, ramUsageByHost := cc.ClusterManager.ReallyExpensiveAssessmentOfTheSystemState()
			for host, oomCount := range oomCountByHost {
				ch <- prometheus.MustNewConstMetric(
					oomCountDesc,
					prometheus.CounterValue,
					float64(oomCount),
					host,
				)
			}
			for host, ramUsage := range ramUsageByHost {
				ch <- prometheus.MustNewConstMetric(
					ramUsageDesc,
					prometheus.GaugeValue,
					ramUsage,
					host,
				)
			}
		}
		
		// NewClusterManager first creates a Prometheus-ignorant ClusterManager
		// instance. Then, it creates a ClusterManagerCollector for the just created
		// ClusterManager. Finally, it registers the ClusterManagerCollector with a
		// wrapping Registerer that adds the zone as a label. In this way, the metrics
		// collected by different ClusterManagerCollectors do not collide.
		func NewClusterManager(zone string, reg prometheus.Registerer) *ClusterManager {
			c := &ClusterManager{
				Zone: zone,
			}
			cc := ClusterManagerCollector{ClusterManager: c}
			prometheus.WrapRegistererWith(prometheus.Labels{"zone": zone}, reg).MustRegister(cc)
			return c
		}
		
		func main() {
			// Since we are dealing with custom Collector implementations, it might
			// be a good idea to try it out with a pedantic registry.
			reg := prometheus.NewPedanticRegistry()
		
			// Construct cluster managers. In real code, we would assign them to
			// variables to then do something with them.
			NewClusterManager("db", reg)
			NewClusterManager("ca", reg)
		
			// Add the standard process and Go metrics to the custom registry.
			reg.MustRegister(
				prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}),
				prometheus.NewGoCollector(),
			)
		
			http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{}))
			log.Fatal(http.ListenAndServe(":8080", nil))
		}

	MetricVec
		package main
		
		import (
			"fmt"
		
			"google.golang.org/protobuf/proto"
		
			dto "github.com/prometheus/client_model/go"
		
			"github.com/prometheus/client_golang/prometheus"
		)
		
		// Info implements an info pseudo-metric, which is modeled as a Gauge that
		// always has a value of 1. In practice, you would just use a Gauge directly,
		// but for this example, we pretend it would be useful to have a “native”
		// implementation.
		type Info struct {
			desc       *prometheus.Desc
			labelPairs []*dto.LabelPair
		}
		
		func (i Info) Desc() *prometheus.Desc {
			return i.desc
		}
		
		func (i Info) Write(out *dto.Metric) error {
			out.Label = i.labelPairs
			out.Gauge = &dto.Gauge{Value: proto.Float64(1)}
			return nil
		}
		
		// InfoVec is the vector version for Info. As an info metric never changes, we
		// wouldn't really need to wrap GetMetricWithLabelValues and GetMetricWith
		// because Info has no additional methods compared to the vanilla Metric that
		// the unwrapped MetricVec methods return. However, to demonstrate all there is
		// to do to fully implement a vector for a custom Metric implementation, we do
		// it in this example anyway.
		type InfoVec struct {
			*prometheus.MetricVec
		}
		
		func NewInfoVec(name, help string, labelNames []string) *InfoVec {
			desc := prometheus.NewDesc(name, help, labelNames, nil)
			return &InfoVec{
				MetricVec: prometheus.NewMetricVec(desc, func(lvs ...string) prometheus.Metric {
					if len(lvs) != len(labelNames) {
						panic("inconsistent label cardinality")
					}
					return Info{desc: desc, labelPairs: prometheus.MakeLabelPairs(desc, lvs)}
				}),
			}
		}
		
		func (v *InfoVec) GetMetricWithLabelValues(lvs ...string) (Info, error) {
			metric, err := v.MetricVec.GetMetricWithLabelValues(lvs...)
			return metric.(Info), err
		}
		
		func (v *InfoVec) GetMetricWith(labels prometheus.Labels) (Info, error) {
			metric, err := v.MetricVec.GetMetricWith(labels)
			return metric.(Info), err
		}
		
		func (v *InfoVec) WithLabelValues(lvs ...string) Info {
			i, err := v.GetMetricWithLabelValues(lvs...)
			if err != nil {
				panic(err)
			}
			return i
		}
		
		func (v *InfoVec) With(labels prometheus.Labels) Info {
			i, err := v.GetMetricWith(labels)
			if err != nil {
				panic(err)
			}
			return i
		}
		
		func (v *InfoVec) CurryWith(labels prometheus.Labels) (*InfoVec, error) {
			vec, err := v.MetricVec.CurryWith(labels)
			if vec != nil {
				return &InfoVec{vec}, err
			}
			return nil, err
		}
		
		func (v *InfoVec) MustCurryWith(labels prometheus.Labels) *InfoVec {
			vec, err := v.CurryWith(labels)
			if err != nil {
				panic(err)
			}
			return vec
		}
		
		func main() {
			infoVec := NewInfoVec(
				"library_version_info",
				"Versions of the libraries used in this binary.",
				[]string{"library", "version"},
			)
		
			infoVec.WithLabelValues("prometheus/client_golang", "1.7.1")
			infoVec.WithLabelValues("k8s.io/client-go", "0.18.8")
		
			// Just for demonstration, let's check the state of the InfoVec by
			// registering it with a custom registry and then let it collect the
			// metrics.
			reg := prometheus.NewRegistry()
			reg.MustRegister(infoVec)
		
			metricFamilies, err := reg.Gather()
			if err != nil || len(metricFamilies) != 1 {
				panic("unexpected behavior of custom test registry")
			}
			fmt.Println(toNormalizedJSON(metricFamilies[0]))
		
		}

	Timer
		package main
		
		import (
			"math/rand"
			"time"
		
			"github.com/prometheus/client_golang/prometheus"
		)
		
		var requestDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
			Name:    "example_request_duration_seconds",
			Help:    "Histogram for the runtime of a simple example function.",
			Buckets: prometheus.LinearBuckets(0.01, 0.01, 10),
		})
		
		func main() {
			// timer times this example function. It uses a Histogram, but a Summary
			// would also work, as both implement Observer. Check out
			// https://prometheus.io/docs/practices/histograms/ for differences.
			timer := prometheus.NewTimer(requestDuration)
			defer timer.ObserveDuration()
		
			// Do something here that takes time.
			time.Sleep(time.Duration(rand.NormFloat64()*10000+50000) * time.Microsecond)
		}

	Timer_complex
		package main
		
		import (
			"net/http"
		
			"github.com/prometheus/client_golang/prometheus"
		)
		
		// apiRequestDuration tracks the duration separate for each HTTP status
		// class (1xx, 2xx, ...). This creates a fair amount of time series on
		// the Prometheus server. Usually, you would track the duration of
		// serving HTTP request without partitioning by outcome. Do something
		// like this only if needed. Also note how only status classes are
		// tracked, not every single status code. The latter would create an
		// even larger amount of time series. Request counters partitioned by
		// status code are usually OK as each counter only creates one time
		// series. Histograms are way more expensive, so partition with care and
		// only where you really need separate latency tracking. Partitioning by
		// status class is only an example. In concrete cases, other partitions
		// might make more sense.
		var apiRequestDuration = prometheus.NewHistogramVec(
			prometheus.HistogramOpts{
				Name:    "api_request_duration_seconds",
				Help:    "Histogram for the request duration of the public API, partitioned by status class.",
				Buckets: prometheus.ExponentialBuckets(0.1, 1.5, 5),
			},
			[]string{"status_class"},
		)
		
		func handler(w http.ResponseWriter, r *http.Request) {
			status := http.StatusOK
			// The ObserverFunc gets called by the deferred ObserveDuration and
			// decides which Histogram's Observe method is called.
			timer := prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) {
				switch {
				case status >= 500: // Server error.
					apiRequestDuration.WithLabelValues("5xx").Observe(v)
				case status >= 400: // Client error.
					apiRequestDuration.WithLabelValues("4xx").Observe(v)
				case status >= 300: // Redirection.
					apiRequestDuration.WithLabelValues("3xx").Observe(v)
				case status >= 200: // Success.
					apiRequestDuration.WithLabelValues("2xx").Observe(v)
				default: // Informational.
					apiRequestDuration.WithLabelValues("1xx").Observe(v)
				}
			}))
			defer timer.ObserveDuration()
		
			// Handle the request. Set status accordingly.
			// ...
		}
		
		func main() {
			http.HandleFunc("/api", handler)
		}

	Timer_gauge
		package main
		
		import (
			"os"
		
			"github.com/prometheus/client_golang/prometheus"
		)
		
		// If a function is called rarely (i.e. not more often than scrapes
		// happen) or ideally only once (like in a batch job), it can make sense
		// to use a Gauge for timing the function call. For timing a batch job
		// and pushing the result to a Pushgateway, see also the comprehensive
		// example in the push package.
		var funcDuration = prometheus.NewGauge(prometheus.GaugeOpts{
			Name: "example_function_duration_seconds",
			Help: "Duration of the last call of an example function.",
		})
		
		func run() error {
			// The Set method of the Gauge is used to observe the duration.
			timer := prometheus.NewTimer(prometheus.ObserverFunc(funcDuration.Set))
			defer timer.ObserveDuration()
		
			// Do something. Return errors as encountered. The use of 'defer' above
			// makes sure the function is still timed properly.
			return nil
		}
		
		func main() {
			if err := run(); err != nil {
				os.Exit(1)
			}
		}


Package-Level Type Names (total 50)

	/* sort by: alphabet | popularity */
	 type AlreadyRegisteredError (struct)
		AlreadyRegisteredError is returned by the Register method if the Collector to
		be registered has already been registered before, or a different Collector
		that collects the same metrics has been registered before. Registration fails
		in that case, but you can detect from the kind of error what has
		happened. The error contains fields for the existing Collector and the
		(rejected) new Collector that equals the existing one. This can be used to
		find out if an equal Collector has been registered before and switch over to
		using the old one, as demonstrated in the example.

		Fields (total 2)
			ExistingCollector Collector
			NewCollector Collector
		Methods (only one)
			( AlreadyRegisteredError) Error() string
		Implements (at least one exported)
			 AlreadyRegisteredError : error

	 type Collector (interface)
		Collector is the interface implemented by anything that can be used by
		Prometheus to collect metrics. A Collector has to be registered for
		collection. See Registerer.Register.
		
		The stock metrics provided by this package (Gauge, Counter, Summary,
		Histogram, Untyped) are also Collectors (which only ever collect one metric,
		namely itself). An implementer of Collector may, however, collect multiple
		metrics in a coordinated fashion and/or create metrics on the fly. Examples
		for collectors already implemented in this library are the metric vectors
		(i.e. collection of multiple instances of the same Metric but with different
		label values) like GaugeVec or SummaryVec, and the ExpvarCollector.

		Methods (total 2)
			( Collector) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( Collector) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

		Implemented By (at least 15)
			 CollectorFunc
			 Counter (interface)
			 CounterFunc (interface)
			 CounterVec
			 Gauge (interface)
			 GaugeFunc (interface)
			 GaugeVec
			 Histogram (interface)
			 HistogramVec
			*MetricVec
			 ObserverVec (interface)
			*Registry
			 Summary (interface)
			 SummaryVec
			 UntypedFunc (interface)
		As Outputs Of (at least 4)
			func NewBuildInfoCollector() Collector
			func NewExpvarCollector(exports map[string]*Desc) Collector
			func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector
			func NewProcessCollector(opts ProcessCollectorOpts) Collector
		As Inputs Of (at least 12)
			func DescribeByCollect(c Collector, descs chan<- *Desc)
			func MustRegister(cs ...Collector)
			func Register(c Collector) error
			func Unregister(c Collector) bool
			func Registerer.MustRegister(...Collector)
			func Registerer.Register(Collector) error
			func Registerer.Unregister(Collector) bool
			func (*Registry).MustRegister(cs ...Collector)
			func (*Registry).Register(c Collector) error
			func (*Registry).Unregister(c Collector) bool
			func github.com/prometheus/client_golang/prometheus/push.(*Pusher).Collector(c Collector) *push.Pusher
			func github.com/libp2p/go-libp2p/p2p/metricshelper.RegisterCollectors(reg Registerer, collectors ...Collector)

	 type CollectorFunc (func)
		CollectorFunc is a convenient way to implement a Prometheus Collector
		without interface boilerplate.
		This implementation is based on DescribeByCollect method.
		familiarize yourself to it before using.

		Methods (total 2)
			( CollectorFunc) Collect(ch chan<- Metric)
				Collect calls the defined CollectorFunc function with the provided Metrics channel

			( CollectorFunc) Describe(ch chan<- *Desc)
				Describe sends the descriptor information using DescribeByCollect

		Implements (at least one exported)
			 CollectorFunc : Collector

	 type ConstrainableLabels (interface)
		ConstrainableLabels is an interface that allows creating of labels that can
		be optionally constrained.
		
			prometheus.V2().NewCounterVec(CounterVecOpts{
			  CounterOpts: {...}, // Usual CounterOpts fields
			  VariableLabels: []ConstrainedLabels{
			    {Name: "A"},
			    {Name: "B", Constraint: func(v string) string { ... }},
			  },
			})

		Implemented By (at least 2)
			 ConstrainedLabels
			 UnconstrainedLabels

	 type ConstrainedLabel (struct)
		ConstrainedLabels represents a label name and its constrain function
		to normalize label values. This type is commonly used when constructing
		metric vector Collectors.

		Fields (total 2)
			Constraint LabelConstraint
			Name string

	 type ConstrainedLabels ([])
		ConstrainedLabels represents a collection of label name -> constrain function
		to normalize label values. This type is commonly used when constructing
		metric vector Collectors.

		Implements (at least one exported)
			 ConstrainedLabels : ConstrainableLabels

	 type Counter (interface)
		Counter is a Metric that represents a single numerical value that only ever
		goes up. That implies that it cannot be used to count items whose number can
		also go down, e.g. the number of currently running goroutines. Those
		"counters" are represented by Gauges.
		
		A Counter is typically used to count requests served, tasks completed, errors
		occurred, etc.
		
		To create Counter instances, use NewCounter.

		Methods (total 6)
			( Counter) Add(float64)
				Add adds the given value to the counter. It panics if the value is <
				0.

			( Counter) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( Counter) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( Counter) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( Counter) Inc()
				Inc increments the counter by 1. Use Add to increment it by arbitrary
				non-negative values.

			( Counter) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least one exported)
			 Gauge (interface)
		Implements (at least 5)
			 Counter : Collector
			 Counter : CounterFunc
			 Counter : GaugeFunc
			 Counter : Metric
			 Counter : UntypedFunc
		As Outputs Of (at least 7)
			func NewCounter(opts CounterOpts) Counter
			func (*CounterVec).GetMetricWith(labels Labels) (Counter, error)
			func (*CounterVec).GetMetricWithLabelValues(lvs ...string) (Counter, error)
			func (*CounterVec).With(labels Labels) Counter
			func (*CounterVec).WithLabelValues(lvs ...string) Counter
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounter(opts CounterOpts) Counter
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounter(opts CounterOpts) Counter

	 type CounterFunc (interface)
		CounterFunc is a Counter whose value is determined at collect time by calling a
		provided function.
		
		To create CounterFunc instances, use NewCounterFunc.

		Methods (total 4)
			( CounterFunc) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( CounterFunc) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( CounterFunc) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( CounterFunc) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least 6)
			 Counter (interface)
			 Gauge (interface)
			 GaugeFunc (interface)
			 Histogram (interface)
			 Summary (interface)
			 UntypedFunc (interface)
		Implements (at least 4)
			 CounterFunc : Collector
			 CounterFunc : GaugeFunc
			 CounterFunc : Metric
			 CounterFunc : UntypedFunc
		As Outputs Of (at least 3)
			func NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc

	 type CounterOpts Opts (struct)
		CounterOpts is an alias for Opts. See there for doc comments.

		Fields (total 5)
			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			Subsystem string
		As Inputs Of (at least 9)
			func NewCounter(opts CounterOpts) Counter
			func NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
			func NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounter(opts CounterOpts) Counter
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounter(opts CounterOpts) Counter
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec

	 type CounterVec (struct)
		CounterVec is a Collector that bundles a set of Counters 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
		(e.g. number of HTTP requests, partitioned by response code and
		method). Create instances with NewCounterVec.

		Fields (only one)
			MetricVec *MetricVec
		Methods (total 12)
			( CounterVec) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*CounterVec) CurryWith(labels Labels) (*CounterVec, error)
				CurryWith returns a vector curried with the provided labels, i.e. the
				returned vector has those labels pre-set for all labeled operations performed
				on it. The cardinality of the curried vector is reduced accordingly. The
				order of the remaining labels stays the same (just with the curried labels
				taken out of the sequence – which is relevant for the
				(GetMetric)WithLabelValues methods). It is possible to curry a curried
				vector, but only with labels not yet used for currying before.
				
				The metrics contained in the CounterVec are shared between the curried and
				uncurried vectors. They are just accessed differently. Curried and uncurried
				vectors behave identically in terms of collection. Only one must be
				registered with a given registry (usually the uncurried version). The Reset
				method deletes all metrics, even if called on a curried vector.

			( CounterVec) Delete(labels Labels) bool
				Delete deletes the metric where the variable labels are the same as those
				passed in as labels. It returns true if a metric was deleted.
				
				It is not an error if the number and names of the Labels are inconsistent
				with those of the VariableLabels in Desc. However, such inconsistent Labels
				can never match an actual metric, so the method will always return false in
				that case.
				
				This method is used for the same purpose as DeleteLabelValues(...string). See
				there for pros and cons of the two methods.

			( CounterVec) DeleteLabelValues(lvs ...string) bool
				DeleteLabelValues removes the metric where the variable labels are the same
				as those passed in as labels (same order as the VariableLabels in Desc). It
				returns true if a metric was deleted.
				
				It is not an error if the number of label values is not the same as the
				number of VariableLabels in Desc. However, such inconsistent label count can
				never match an actual metric, so the method will always return false in that
				case.
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider Delete(Labels) as an
				alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the CounterVec example.

			( CounterVec) DeletePartialMatch(labels Labels) int
				DeletePartialMatch deletes all metrics where the variable labels contain all of those
				passed in as labels. The order of the labels does not matter.
				It returns the number of metrics deleted.
				
				Note that curried labels will never be matched if deleting from the curried vector.
				To match curried labels with DeletePartialMatch, it must be called on the base vector.

			( CounterVec) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*CounterVec) GetMetricWith(labels Labels) (Counter, error)
				GetMetricWith returns the Counter for the given Labels map (the label names
				must match those of the variable labels in Desc). If that label map is
				accessed for the first time, a new Counter is created. Implications of
				creating a Counter without using it and keeping the Counter for later use are
				the same as for GetMetricWithLabelValues.
				
				An error is returned if the number and names of the Labels are inconsistent
				with those of the variable labels in Desc (minus any curried labels).
				
				This method is used for the same purpose as
				GetMetricWithLabelValues(...string). See there for pros and cons of the two
				methods.

			(*CounterVec) GetMetricWithLabelValues(lvs ...string) (Counter, error)
				GetMetricWithLabelValues returns the Counter for the given slice of label
				values (same order as the variable labels in Desc). If that combination of
				label values is accessed for the first time, a new Counter is created.
				
				It is possible to call this method without using the returned Counter to only
				create the new Counter but leave it at its starting value 0. See also the
				SummaryVec example.
				
				Keeping the Counter for later use is possible (and should be considered if
				performance is critical), but keep in mind that Reset, DeleteLabelValues and
				Delete can be used to delete the Counter from the CounterVec. In that case,
				the Counter will still exist, but it will not be exported anymore, even if a
				Counter with the same label values is created later.
				
				An error is returned if the number of label values is not the same as the
				number of variable labels in Desc (minus any curried labels).
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as
				an alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the GaugeVec example.

			(*CounterVec) MustCurryWith(labels Labels) *CounterVec
				MustCurryWith works as CurryWith but panics where CurryWith would have
				returned an error.

			( CounterVec) Reset()
				Reset deletes all metrics in this vector.

			(*CounterVec) With(labels Labels) Counter
				With works as GetMetricWith, but panics where GetMetricWithLabels would have
				returned an error. Not returning an error allows shortcuts like
				
					myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Add(42)

			(*CounterVec) WithLabelValues(lvs ...string) Counter
				WithLabelValues works as GetMetricWithLabelValues, but panics where
				GetMetricWithLabelValues would have returned an error. Not returning an
				error allows shortcuts like
				
					myVec.WithLabelValues("404", "GET").Add(42)

		Implements (at least one exported)
			 CounterVec : Collector
		As Outputs Of (at least 5)
			func NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec
			func (*CounterVec).CurryWith(labels Labels) (*CounterVec, error)
			func (*CounterVec).MustCurryWith(labels Labels) *CounterVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec

	 type CounterVecOpts (struct)
		CounterVecOpts bundles the options to create a CounterVec metric.
		It is mandatory to set CounterOpts, see there for mandatory fields. VariableLabels
		is optional and can safely be left to its default value.

		Fields (total 7)
			CounterOpts CounterOpts
			CounterOpts.ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			CounterOpts.Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			CounterOpts.Name string
			CounterOpts.Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			CounterOpts.Subsystem string
			VariableLabels ConstrainableLabels
				VariableLabels are used to partition the metric vector by the given set
				of labels. Each label value will be constrained with the optional Constraint
				function, if provided.


	 type Desc (struct)
		Desc is the descriptor used by every Prometheus Metric. It is essentially
		the immutable meta-data of a Metric. The normal Metric implementations
		included in this package manage their Desc under the hood. Users only have to
		deal with Desc if they use advanced features like the ExpvarCollector or
		custom Collectors and Metrics.
		
		Descriptors registered with the same registry have to fulfill certain
		consistency and uniqueness criteria if they share the same fully-qualified
		name: They must have the same help string and the same label names (aka label
		dimensions) in each, constLabels and variableLabels, but they must differ in
		the values of the constLabels.
		
		Descriptors that share the same fully-qualified names and the same label
		values of their constLabels are considered equal.
		
		Use NewDesc to create new Desc instances.

		Methods (only one)
			(*Desc) String() string
		Implements (at least 2)
			*Desc : expvar.Var
			*Desc : fmt.Stringer
		As Outputs Of (at least 10)
			func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *Desc
			func NewInvalidDesc(err error) *Desc
			func Counter.Desc() *Desc
			func CounterFunc.Desc() *Desc
			func Gauge.Desc() *Desc
			func GaugeFunc.Desc() *Desc
			func Histogram.Desc() *Desc
			func Metric.Desc() *Desc
			func Summary.Desc() *Desc
			func UntypedFunc.Desc() *Desc
		As Inputs Of (at least 31)
			func DescribeByCollect(c Collector, descs chan<- *Desc)
			func MakeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair
			func MustNewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) Metric
			func MustNewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) Metric
			func MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric
			func MustNewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) Metric
			func MustNewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, nativeHistogramSchema int32, nativeHistogramZeroThreshold float64, createdTimestamp time.Time, labelValues ...string) Metric
			func MustNewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) Metric
			func MustNewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) Metric
			func NewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) (Metric, error)
			func NewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) (Metric, error)
			func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error)
			func NewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) (Metric, error)
			func NewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, schema int32, zeroThreshold float64, createdTimestamp time.Time, labelValues ...string) (Metric, error)
			func NewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) (Metric, error)
			func NewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) (Metric, error)
			func NewExpvarCollector(exports map[string]*Desc) Collector
			func NewInvalidMetric(desc *Desc, err error) Metric
			func NewMetricVec(desc *Desc, newMetric func(lvs ...string) Metric) *MetricVec
			func Collector.Describe(chan<- *Desc)
			func CollectorFunc.Describe(ch chan<- *Desc)
			func Counter.Describe(chan<- *Desc)
			func CounterFunc.Describe(chan<- *Desc)
			func Gauge.Describe(chan<- *Desc)
			func GaugeFunc.Describe(chan<- *Desc)
			func Histogram.Describe(chan<- *Desc)
			func (*MetricVec).Describe(ch chan<- *Desc)
			func ObserverVec.Describe(chan<- *Desc)
			func (*Registry).Describe(ch chan<- *Desc)
			func Summary.Describe(chan<- *Desc)
			func UntypedFunc.Describe(chan<- *Desc)

	 type Exemplar (struct)
		Exemplar is easier to use, user-facing representation of *dto.Exemplar.

		Fields (total 3)
			Labels Labels
			Timestamp time.Time
				Optional.
				Default value (time.Time{}) indicates its empty, which should be
				understood as time.Now() time at the moment of creation of metric.

			Value float64
		As Inputs Of (at least 2)
			func MustNewMetricWithExemplars(m Metric, exemplars ...Exemplar) Metric
			func NewMetricWithExemplars(m Metric, exemplars ...Exemplar) (Metric, error)

	 type ExemplarAdder (interface)
		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 128 runes in total.

		Methods (only one)
			( ExemplarAdder) AddWithExemplar(value float64, exemplar Labels)

	 type ExemplarObserver (interface)
		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 128 runes in total.

		Methods (only one)
			( ExemplarObserver) ObserveWithExemplar(value float64, exemplar Labels)

	 type Gatherer (interface)
		Gatherer is the interface for the part of a registry in charge of gathering
		the collected metrics into a number of MetricFamilies. The Gatherer interface
		comes with the same general implication as described for the Registerer
		interface.

		Methods (only one)
			( Gatherer) Gather() ([]*dto.MetricFamily, error)
				Gather calls the Collect method of the registered Collectors and then
				gathers the collected metrics into a lexicographically sorted slice
				of uniquely named MetricFamily protobufs. Gather ensures that the
				returned slice is valid and self-consistent so that it can be used
				for valid exposition. As an exception to the strict consistency
				requirements described for metric.Desc, Gather will tolerate
				different sets of label names for metrics of the same metric family.
				
				Even if an error occurs, Gather attempts to gather as many metrics as
				possible. Hence, if a non-nil error is returned, the returned
				MetricFamily slice could be nil (in case of a fatal error that
				prevented any meaningful metric collection) or contain a number of
				MetricFamily protobufs, some of which might be incomplete, and some
				might be missing altogether. The returned error (which might be a
				MultiError) explains the details. Note that this is mostly useful for
				debugging purposes. If the gathered protobufs are to be used for
				exposition in actual monitoring, it is almost always better to not
				expose an incomplete result and instead disregard the returned
				MetricFamily protobufs in case the returned error is non-nil.

		Implemented By (at least 3)
			 GathererFunc
			 Gatherers
			*Registry
		As Inputs Of (at least 3)
			func ToTransactionalGatherer(g Gatherer) TransactionalGatherer
			func WriteToTextfile(filename string, g Gatherer) error
			func github.com/prometheus/client_golang/prometheus/push.(*Pusher).Gatherer(g Gatherer) *push.Pusher
		As Types Of (only one)
			  var DefaultGatherer

	 type GathererFunc (func)
		GathererFunc turns a function into a Gatherer.

		Methods (only one)
			( GathererFunc) Gather() ([]*dto.MetricFamily, error)
				Gather implements Gatherer.

		Implements (at least one exported)
			 GathererFunc : Gatherer

	 type Gatherers ([])
		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 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.
		
		Gatherers can be used to merge the Gather results from multiple
		Registries. It also provides a way to directly inject existing MetricFamily
		protobufs into the gathering by creating a custom Gatherer with a Gather
		method that simply returns the existing MetricFamily protobufs. Note that no
		registration is involved (in contrast to Collector registration), so
		obviously registration-time checks cannot happen. Any inconsistencies between
		the gathered MetricFamilies are reported as errors by the Gather method, and
		inconsistent Metrics are dropped. Invalid parts of the MetricFamilies
		(e.g. syntactically invalid metric or label names) will go undetected.

		Methods (only one)
			( Gatherers) Gather() ([]*dto.MetricFamily, error)
				Gather implements Gatherer.

		Implements (at least one exported)
			 Gatherers : Gatherer

	 type Gauge (interface)
		Gauge is a Metric that represents a single numerical value that can
		arbitrarily go up and down.
		
		A Gauge is typically used for measured values like temperatures or current
		memory usage, but also "counts" that can go up and down, like the number of
		running goroutines.
		
		To create Gauge instances, use NewGauge.

		Methods (total 10)
			( Gauge) Add(float64)
				Add adds the given value to the Gauge. (The value can be negative,
				resulting in a decrease of the Gauge.)

			( Gauge) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( Gauge) Dec()
				Dec decrements the Gauge by 1. Use Sub to decrement it by arbitrary
				values.

			( Gauge) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( Gauge) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( Gauge) Inc()
				Inc increments the Gauge by 1. Use Add to increment it by arbitrary
				values.

			( Gauge) Set(float64)
				Set sets the Gauge to an arbitrary value.

			( Gauge) SetToCurrentTime()
				SetToCurrentTime sets the Gauge to the current Unix time in seconds.

			( Gauge) Sub(float64)
				Sub subtracts the given value from the Gauge. (The value can be
				negative, resulting in an increase of the Gauge.)

			( Gauge) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implements (at least 6)
			 Gauge : Collector
			 Gauge : Counter
			 Gauge : CounterFunc
			 Gauge : GaugeFunc
			 Gauge : Metric
			 Gauge : UntypedFunc
		As Outputs Of (at least 7)
			func NewGauge(opts GaugeOpts) Gauge
			func (*GaugeVec).GetMetricWith(labels Labels) (Gauge, error)
			func (*GaugeVec).GetMetricWithLabelValues(lvs ...string) (Gauge, error)
			func (*GaugeVec).With(labels Labels) Gauge
			func (*GaugeVec).WithLabelValues(lvs ...string) Gauge
			func github.com/prometheus/client_golang/prometheus/promauto.NewGauge(opts GaugeOpts) Gauge
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGauge(opts GaugeOpts) Gauge

	 type GaugeFunc (interface)
		GaugeFunc is a Gauge whose value is determined at collect time by calling a
		provided function.
		
		To create GaugeFunc instances, use NewGaugeFunc.

		Methods (total 4)
			( GaugeFunc) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( GaugeFunc) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( GaugeFunc) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( GaugeFunc) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least 6)
			 Counter (interface)
			 CounterFunc (interface)
			 Gauge (interface)
			 Histogram (interface)
			 Summary (interface)
			 UntypedFunc (interface)
		Implements (at least 4)
			 GaugeFunc : Collector
			 GaugeFunc : CounterFunc
			 GaugeFunc : Metric
			 GaugeFunc : UntypedFunc
		As Outputs Of (at least 3)
			func NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc

	 type GaugeOpts Opts (struct)
		GaugeOpts is an alias for Opts. See there for doc comments.

		Fields (total 5)
			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			Subsystem string
		As Inputs Of (at least 9)
			func NewGauge(opts GaugeOpts) Gauge
			func NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
			func NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewGauge(opts GaugeOpts) Gauge
			func github.com/prometheus/client_golang/prometheus/promauto.NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGauge(opts GaugeOpts) Gauge
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec

	 type GaugeVec (struct)
		GaugeVec is a Collector that bundles a set of Gauges 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
		(e.g. number of operations queued, partitioned by user and operation
		type). Create instances with NewGaugeVec.

		Fields (only one)
			MetricVec *MetricVec
		Methods (total 12)
			( GaugeVec) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*GaugeVec) CurryWith(labels Labels) (*GaugeVec, error)
				CurryWith returns a vector curried with the provided labels, i.e. the
				returned vector has those labels pre-set for all labeled operations performed
				on it. The cardinality of the curried vector is reduced accordingly. The
				order of the remaining labels stays the same (just with the curried labels
				taken out of the sequence – which is relevant for the
				(GetMetric)WithLabelValues methods). It is possible to curry a curried
				vector, but only with labels not yet used for currying before.
				
				The metrics contained in the GaugeVec are shared between the curried and
				uncurried vectors. They are just accessed differently. Curried and uncurried
				vectors behave identically in terms of collection. Only one must be
				registered with a given registry (usually the uncurried version). The Reset
				method deletes all metrics, even if called on a curried vector.

			( GaugeVec) Delete(labels Labels) bool
				Delete deletes the metric where the variable labels are the same as those
				passed in as labels. It returns true if a metric was deleted.
				
				It is not an error if the number and names of the Labels are inconsistent
				with those of the VariableLabels in Desc. However, such inconsistent Labels
				can never match an actual metric, so the method will always return false in
				that case.
				
				This method is used for the same purpose as DeleteLabelValues(...string). See
				there for pros and cons of the two methods.

			( GaugeVec) DeleteLabelValues(lvs ...string) bool
				DeleteLabelValues removes the metric where the variable labels are the same
				as those passed in as labels (same order as the VariableLabels in Desc). It
				returns true if a metric was deleted.
				
				It is not an error if the number of label values is not the same as the
				number of VariableLabels in Desc. However, such inconsistent label count can
				never match an actual metric, so the method will always return false in that
				case.
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider Delete(Labels) as an
				alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the CounterVec example.

			( GaugeVec) DeletePartialMatch(labels Labels) int
				DeletePartialMatch deletes all metrics where the variable labels contain all of those
				passed in as labels. The order of the labels does not matter.
				It returns the number of metrics deleted.
				
				Note that curried labels will never be matched if deleting from the curried vector.
				To match curried labels with DeletePartialMatch, it must be called on the base vector.

			( GaugeVec) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*GaugeVec) GetMetricWith(labels Labels) (Gauge, error)
				GetMetricWith returns the Gauge for the given Labels map (the label names
				must match those of the variable labels in Desc). If that label map is
				accessed for the first time, a new Gauge is created. Implications of
				creating a Gauge without using it and keeping the Gauge for later use are
				the same as for GetMetricWithLabelValues.
				
				An error is returned if the number and names of the Labels are inconsistent
				with those of the variable labels in Desc (minus any curried labels).
				
				This method is used for the same purpose as
				GetMetricWithLabelValues(...string). See there for pros and cons of the two
				methods.

			(*GaugeVec) GetMetricWithLabelValues(lvs ...string) (Gauge, error)
				GetMetricWithLabelValues returns the Gauge for the given slice of label
				values (same order as the variable labels in Desc). If that combination of
				label values is accessed for the first time, a new Gauge is created.
				
				It is possible to call this method without using the returned Gauge to only
				create the new Gauge but leave it at its starting value 0. See also the
				SummaryVec example.
				
				Keeping the Gauge for later use is possible (and should be considered if
				performance is critical), but keep in mind that Reset, DeleteLabelValues and
				Delete can be used to delete the Gauge from the GaugeVec. In that case, the
				Gauge will still exist, but it will not be exported anymore, even if a
				Gauge with the same label values is created later. See also the CounterVec
				example.
				
				An error is returned if the number of label values is not the same as the
				number of variable labels in Desc (minus any curried labels).
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as
				an alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).

			(*GaugeVec) MustCurryWith(labels Labels) *GaugeVec
				MustCurryWith works as CurryWith but panics where CurryWith would have
				returned an error.

			( GaugeVec) Reset()
				Reset deletes all metrics in this vector.

			(*GaugeVec) With(labels Labels) Gauge
				With works as GetMetricWith, but panics where GetMetricWithLabels would have
				returned an error. Not returning an error allows shortcuts like
				
					myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Add(42)

			(*GaugeVec) WithLabelValues(lvs ...string) Gauge
				WithLabelValues works as GetMetricWithLabelValues, but panics where
				GetMetricWithLabelValues would have returned an error. Not returning an
				error allows shortcuts like
				
					myVec.WithLabelValues("404", "GET").Add(42)

		Implements (at least one exported)
			 GaugeVec : Collector
		As Outputs Of (at least 5)
			func NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec
			func (*GaugeVec).CurryWith(labels Labels) (*GaugeVec, error)
			func (*GaugeVec).MustCurryWith(labels Labels) *GaugeVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec

	 type GaugeVecOpts (struct)
		GaugeVecOpts bundles the options to create a GaugeVec metric.
		It is mandatory to set GaugeOpts, see there for mandatory fields. VariableLabels
		is optional and can safely be left to its default value.

		Fields (total 7)
			GaugeOpts GaugeOpts
			GaugeOpts.ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			GaugeOpts.Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			GaugeOpts.Name string
			GaugeOpts.Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			GaugeOpts.Subsystem string
			VariableLabels ConstrainableLabels
				VariableLabels are used to partition the metric vector by the given set
				of labels. Each label value will be constrained with the optional Constraint
				function, if provided.


	 type Histogram (interface)
		A Histogram counts individual observations from an event or sample stream in
		configurable static buckets (or in dynamic sparse buckets as part of the
		experimental Native Histograms, see below for more details). Similar to a
		Summary, it also provides a sum of observations and an observation count.
		
		On the Prometheus server, quantiles can be calculated from a Histogram using
		the histogram_quantile PromQL function.
		
		Note that Histograms, in contrast to Summaries, can be aggregated in PromQL
		(see the documentation for detailed procedures). However, Histograms require
		the user to pre-define suitable buckets, and they are in general less
		accurate. (Both problems are addressed by the experimental Native
		Histograms. To use them, configure a NativeHistogramBucketFactor in the
		HistogramOpts. They also require a Prometheus server v2.40+ with the
		corresponding feature flag enabled.)
		
		The Observe method of a Histogram has a very low performance overhead in
		comparison with the Observe method of a Summary.
		
		To create Histogram instances, use NewHistogram.

		Methods (total 5)
			( Histogram) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( Histogram) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( Histogram) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( Histogram) Observe(float64)
				Observe adds a single observation to the histogram. Observations are
				usually positive or zero. Negative observations are accepted but
				prevent current versions of Prometheus from properly detecting
				counter resets in the sum of observations. (The experimental Native
				Histograms handle negative observations properly.) See
				https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations
				for details.

			( Histogram) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least one exported)
			 Summary (interface)
		Implements (at least 7)
			 Histogram : Collector
			 Histogram : CounterFunc
			 Histogram : GaugeFunc
			 Histogram : Metric
			 Histogram : Observer
			 Histogram : Summary
			 Histogram : UntypedFunc
		As Outputs Of (at least 3)
			func NewHistogram(opts HistogramOpts) Histogram
			func github.com/prometheus/client_golang/prometheus/promauto.NewHistogram(opts HistogramOpts) Histogram
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewHistogram(opts HistogramOpts) Histogram

	 type HistogramOpts (struct)
		HistogramOpts bundles the options for creating a Histogram metric. It is
		mandatory to set Name to a non-empty string. All other fields are optional
		and can safely be left at their zero value, although it is strongly
		encouraged to set a Help string.

		Fields (total 13)
			Buckets []float64
				Buckets defines the buckets into which observations are counted. Each
				element in the slice is the upper inclusive bound of a bucket. The
				values must be sorted in strictly increasing order. There is no need
				to add a highest bucket with +Inf bound, it will be added
				implicitly. If Buckets is left as nil or set to a slice of length
				zero, it is replaced by default buckets. The default buckets are
				DefBuckets if no buckets for a native histogram (see below) are used,
				otherwise the default is no buckets. (In other words, if you want to
				use both regular buckets and buckets for a native histogram, you have
				to define the regular buckets here explicitly.)

			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this Histogram.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Histogram (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the Histogram must be a
				valid Prometheus metric name.

			NativeHistogramBucketFactor float64
				If NativeHistogramBucketFactor is greater than one, so-called sparse
				buckets are used (in addition to the regular buckets, if defined
				above). A Histogram with sparse buckets will be ingested as a Native
				Histogram by a Prometheus server with that feature enabled (requires
				Prometheus v2.40+). Sparse buckets are exponential buckets covering
				the whole float64 range (with the exception of the “zero” bucket, see
				NativeHistogramZeroThreshold below). From any one bucket to the next,
				the width of the bucket grows by a constant
				factor. NativeHistogramBucketFactor provides an upper bound for this
				factor (exception see below). The smaller
				NativeHistogramBucketFactor, the more buckets will be used and thus
				the more costly the histogram will become. A generally good trade-off
				between cost and accuracy is a value of 1.1 (each bucket is at most
				10% wider than the previous one), which will result in each power of
				two divided into 8 buckets (e.g. there will be 8 buckets between 1
				and 2, same as between 2 and 4, and 4 and 8, etc.).
				
				Details about the actually used factor: The factor is calculated as
				2^(2^-n), where n is an integer number between (and including) -4 and
				8. n is chosen so that the resulting factor is the largest that is
				still smaller or equal to NativeHistogramBucketFactor. Note that the
				smallest possible factor is therefore approx. 1.00271 (i.e. 2^(2^-8)
				). If NativeHistogramBucketFactor is greater than 1 but smaller than
				2^(2^-8), then the actually used factor is still 2^(2^-8) even though
				it is larger than the provided NativeHistogramBucketFactor.
				
				NOTE: Native Histograms are still an experimental feature. Their
				behavior might still change without a major version
				bump. Subsequently, all NativeHistogram... options here might still
				change their behavior or name (or might completely disappear) without
				a major version bump.

			NativeHistogramExemplarTTL time.Duration
				NativeHistogramExemplarTTL is only checked once
				NativeHistogramMaxExemplars is exceeded. In that case, the
				oldest exemplar is removed if it is older than NativeHistogramExemplarTTL.
				Otherwise, the older exemplar in the pair of exemplars that are closest
				together (on an exponential scale) is removed.
				If NativeHistogramExemplarTTL is left at its zero value, a default value of
				5m is used. To always delete the oldest exemplar, set it to a negative value.

			NativeHistogramMaxBucketNumber uint32
				The next three fields define a strategy to limit the number of
				populated sparse buckets. If NativeHistogramMaxBucketNumber is left
				at zero, the number of buckets is not limited. (Note that this might
				lead to unbounded memory consumption if the values observed by the
				Histogram are sufficiently wide-spread. In particular, this could be
				used as a DoS attack vector. Where the observed values depend on
				external inputs, it is highly recommended to set a
				NativeHistogramMaxBucketNumber.) Once the set
				NativeHistogramMaxBucketNumber is exceeded, the following strategy is
				enacted:
				 - First, if the last reset (or the creation) of the histogram is at
				   least NativeHistogramMinResetDuration ago, then the whole
				   histogram is reset to its initial state (including regular
				   buckets).
				 - If less time has passed, or if NativeHistogramMinResetDuration is
				   zero, no reset is performed. Instead, the zero threshold is
				   increased sufficiently to reduce the number of buckets to or below
				   NativeHistogramMaxBucketNumber, but not to more than
				   NativeHistogramMaxZeroThreshold. Thus, if
				   NativeHistogramMaxZeroThreshold is already at or below the current
				   zero threshold, nothing happens at this step.
				 - After that, if the number of buckets still exceeds
				   NativeHistogramMaxBucketNumber, the resolution of the histogram is
				   reduced by doubling the width of the sparse buckets (up to a
				   growth factor between one bucket to the next of 2^(2^4) = 65536,
				   see above).
				 - Any increased zero threshold or reduced resolution is reset back
				   to their original values once NativeHistogramMinResetDuration has
				   passed (since the last reset or the creation of the histogram).

			NativeHistogramMaxExemplars int
				NativeHistogramMaxExemplars limits the number of exemplars
				that are kept in memory for each native histogram. If you leave it at
				zero, a default value of 10 is used. If no exemplars should be kept specifically
				for native histograms, set it to a negative value. (Scrapers can
				still use the exemplars exposed for classic buckets, which are managed
				independently.)

			NativeHistogramMaxZeroThreshold float64
			NativeHistogramMinResetDuration time.Duration
			NativeHistogramZeroThreshold float64
				All observations with an absolute value of less or equal
				NativeHistogramZeroThreshold are accumulated into a “zero” bucket.
				For best results, this should be close to a bucket boundary. This is
				usually the case if picking a power of two. If
				NativeHistogramZeroThreshold is left at zero,
				DefNativeHistogramZeroThreshold is used as the threshold. To
				configure a zero bucket with an actual threshold of zero (i.e. only
				observations of precisely zero will go into the zero bucket), set
				NativeHistogramZeroThreshold to the NativeHistogramZeroThresholdZero
				constant (or any negative float value).

			Subsystem string
		As Inputs Of (at least 6)
			func NewHistogram(opts HistogramOpts) Histogram
			func NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewHistogram(opts HistogramOpts) Histogram
			func github.com/prometheus/client_golang/prometheus/promauto.NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewHistogram(opts HistogramOpts) Histogram
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec

	 type HistogramVec (struct)
		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
		(e.g. HTTP request latencies, partitioned by status code and method). Create
		instances with NewHistogramVec.

		Fields (only one)
			MetricVec *MetricVec
		Methods (total 12)
			( HistogramVec) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*HistogramVec) CurryWith(labels Labels) (ObserverVec, error)
				CurryWith returns a vector curried with the provided labels, i.e. the
				returned vector has those labels pre-set for all labeled operations performed
				on it. The cardinality of the curried vector is reduced accordingly. The
				order of the remaining labels stays the same (just with the curried labels
				taken out of the sequence – which is relevant for the
				(GetMetric)WithLabelValues methods). It is possible to curry a curried
				vector, but only with labels not yet used for currying before.
				
				The metrics contained in the HistogramVec are shared between the curried and
				uncurried vectors. They are just accessed differently. Curried and uncurried
				vectors behave identically in terms of collection. Only one must be
				registered with a given registry (usually the uncurried version). The Reset
				method deletes all metrics, even if called on a curried vector.

			( HistogramVec) Delete(labels Labels) bool
				Delete deletes the metric where the variable labels are the same as those
				passed in as labels. It returns true if a metric was deleted.
				
				It is not an error if the number and names of the Labels are inconsistent
				with those of the VariableLabels in Desc. However, such inconsistent Labels
				can never match an actual metric, so the method will always return false in
				that case.
				
				This method is used for the same purpose as DeleteLabelValues(...string). See
				there for pros and cons of the two methods.

			( HistogramVec) DeleteLabelValues(lvs ...string) bool
				DeleteLabelValues removes the metric where the variable labels are the same
				as those passed in as labels (same order as the VariableLabels in Desc). It
				returns true if a metric was deleted.
				
				It is not an error if the number of label values is not the same as the
				number of VariableLabels in Desc. However, such inconsistent label count can
				never match an actual metric, so the method will always return false in that
				case.
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider Delete(Labels) as an
				alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the CounterVec example.

			( HistogramVec) DeletePartialMatch(labels Labels) int
				DeletePartialMatch deletes all metrics where the variable labels contain all of those
				passed in as labels. The order of the labels does not matter.
				It returns the number of metrics deleted.
				
				Note that curried labels will never be matched if deleting from the curried vector.
				To match curried labels with DeletePartialMatch, it must be called on the base vector.

			( HistogramVec) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*HistogramVec) GetMetricWith(labels Labels) (Observer, error)
				GetMetricWith returns the Histogram for the given Labels map (the label names
				must match those of the variable labels in Desc). If that label map is
				accessed for the first time, a new Histogram is created. Implications of
				creating a Histogram without using it and keeping the Histogram for later use
				are the same as for GetMetricWithLabelValues.
				
				An error is returned if the number and names of the Labels are inconsistent
				with those of the variable labels in Desc (minus any curried labels).
				
				This method is used for the same purpose as
				GetMetricWithLabelValues(...string). See there for pros and cons of the two
				methods.

			(*HistogramVec) GetMetricWithLabelValues(lvs ...string) (Observer, error)
				GetMetricWithLabelValues returns the Histogram for the given slice of label
				values (same order as the variable labels in Desc). If that combination of
				label values is accessed for the first time, a new Histogram is created.
				
				It is possible to call this method without using the returned Histogram to only
				create the new Histogram but leave it at its starting value, a Histogram without
				any observations.
				
				Keeping the Histogram for later use is possible (and should be considered if
				performance is critical), but keep in mind that Reset, DeleteLabelValues and
				Delete can be used to delete the Histogram from the HistogramVec. In that case, the
				Histogram will still exist, but it will not be exported anymore, even if a
				Histogram with the same label values is created later. See also the CounterVec
				example.
				
				An error is returned if the number of label values is not the same as the
				number of variable labels in Desc (minus any curried labels).
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as
				an alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the GaugeVec example.

			(*HistogramVec) MustCurryWith(labels Labels) ObserverVec
				MustCurryWith works as CurryWith but panics where CurryWith would have
				returned an error.

			( HistogramVec) Reset()
				Reset deletes all metrics in this vector.

			(*HistogramVec) With(labels Labels) Observer
				With works as GetMetricWith but panics where GetMetricWithLabels would have
				returned an error. Not returning an error allows shortcuts like
				
					myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Observe(42.21)

			(*HistogramVec) WithLabelValues(lvs ...string) Observer
				WithLabelValues works as GetMetricWithLabelValues, but panics where
				GetMetricWithLabelValues would have returned an error. Not returning an
				error allows shortcuts like
				
					myVec.WithLabelValues("404", "GET").Observe(42.21)

		Implements (at least 2)
			 HistogramVec : Collector
			*HistogramVec : ObserverVec
		As Outputs Of (at least 3)
			func NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec

	 type HistogramVecOpts (struct)
		HistogramVecOpts bundles the options to create a HistogramVec metric.
		It is mandatory to set HistogramOpts, see there for mandatory fields. VariableLabels
		is optional and can safely be left to its default value.

		Fields (total 15)
			HistogramOpts HistogramOpts
			HistogramOpts.Buckets []float64
				Buckets defines the buckets into which observations are counted. Each
				element in the slice is the upper inclusive bound of a bucket. The
				values must be sorted in strictly increasing order. There is no need
				to add a highest bucket with +Inf bound, it will be added
				implicitly. If Buckets is left as nil or set to a slice of length
				zero, it is replaced by default buckets. The default buckets are
				DefBuckets if no buckets for a native histogram (see below) are used,
				otherwise the default is no buckets. (In other words, if you want to
				use both regular buckets and buckets for a native histogram, you have
				to define the regular buckets here explicitly.)

			HistogramOpts.ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			HistogramOpts.Help string
				Help provides information about this Histogram.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			HistogramOpts.Name string
			HistogramOpts.Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Histogram (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the Histogram must be a
				valid Prometheus metric name.

			HistogramOpts.NativeHistogramBucketFactor float64
				If NativeHistogramBucketFactor is greater than one, so-called sparse
				buckets are used (in addition to the regular buckets, if defined
				above). A Histogram with sparse buckets will be ingested as a Native
				Histogram by a Prometheus server with that feature enabled (requires
				Prometheus v2.40+). Sparse buckets are exponential buckets covering
				the whole float64 range (with the exception of the “zero” bucket, see
				NativeHistogramZeroThreshold below). From any one bucket to the next,
				the width of the bucket grows by a constant
				factor. NativeHistogramBucketFactor provides an upper bound for this
				factor (exception see below). The smaller
				NativeHistogramBucketFactor, the more buckets will be used and thus
				the more costly the histogram will become. A generally good trade-off
				between cost and accuracy is a value of 1.1 (each bucket is at most
				10% wider than the previous one), which will result in each power of
				two divided into 8 buckets (e.g. there will be 8 buckets between 1
				and 2, same as between 2 and 4, and 4 and 8, etc.).
				
				Details about the actually used factor: The factor is calculated as
				2^(2^-n), where n is an integer number between (and including) -4 and
				8. n is chosen so that the resulting factor is the largest that is
				still smaller or equal to NativeHistogramBucketFactor. Note that the
				smallest possible factor is therefore approx. 1.00271 (i.e. 2^(2^-8)
				). If NativeHistogramBucketFactor is greater than 1 but smaller than
				2^(2^-8), then the actually used factor is still 2^(2^-8) even though
				it is larger than the provided NativeHistogramBucketFactor.
				
				NOTE: Native Histograms are still an experimental feature. Their
				behavior might still change without a major version
				bump. Subsequently, all NativeHistogram... options here might still
				change their behavior or name (or might completely disappear) without
				a major version bump.

			HistogramOpts.NativeHistogramExemplarTTL time.Duration
				NativeHistogramExemplarTTL is only checked once
				NativeHistogramMaxExemplars is exceeded. In that case, the
				oldest exemplar is removed if it is older than NativeHistogramExemplarTTL.
				Otherwise, the older exemplar in the pair of exemplars that are closest
				together (on an exponential scale) is removed.
				If NativeHistogramExemplarTTL is left at its zero value, a default value of
				5m is used. To always delete the oldest exemplar, set it to a negative value.

			HistogramOpts.NativeHistogramMaxBucketNumber uint32
				The next three fields define a strategy to limit the number of
				populated sparse buckets. If NativeHistogramMaxBucketNumber is left
				at zero, the number of buckets is not limited. (Note that this might
				lead to unbounded memory consumption if the values observed by the
				Histogram are sufficiently wide-spread. In particular, this could be
				used as a DoS attack vector. Where the observed values depend on
				external inputs, it is highly recommended to set a
				NativeHistogramMaxBucketNumber.) Once the set
				NativeHistogramMaxBucketNumber is exceeded, the following strategy is
				enacted:
				 - First, if the last reset (or the creation) of the histogram is at
				   least NativeHistogramMinResetDuration ago, then the whole
				   histogram is reset to its initial state (including regular
				   buckets).
				 - If less time has passed, or if NativeHistogramMinResetDuration is
				   zero, no reset is performed. Instead, the zero threshold is
				   increased sufficiently to reduce the number of buckets to or below
				   NativeHistogramMaxBucketNumber, but not to more than
				   NativeHistogramMaxZeroThreshold. Thus, if
				   NativeHistogramMaxZeroThreshold is already at or below the current
				   zero threshold, nothing happens at this step.
				 - After that, if the number of buckets still exceeds
				   NativeHistogramMaxBucketNumber, the resolution of the histogram is
				   reduced by doubling the width of the sparse buckets (up to a
				   growth factor between one bucket to the next of 2^(2^4) = 65536,
				   see above).
				 - Any increased zero threshold or reduced resolution is reset back
				   to their original values once NativeHistogramMinResetDuration has
				   passed (since the last reset or the creation of the histogram).

			HistogramOpts.NativeHistogramMaxExemplars int
				NativeHistogramMaxExemplars limits the number of exemplars
				that are kept in memory for each native histogram. If you leave it at
				zero, a default value of 10 is used. If no exemplars should be kept specifically
				for native histograms, set it to a negative value. (Scrapers can
				still use the exemplars exposed for classic buckets, which are managed
				independently.)

			HistogramOpts.NativeHistogramMaxZeroThreshold float64
			HistogramOpts.NativeHistogramMinResetDuration time.Duration
			HistogramOpts.NativeHistogramZeroThreshold float64
				All observations with an absolute value of less or equal
				NativeHistogramZeroThreshold are accumulated into a “zero” bucket.
				For best results, this should be close to a bucket boundary. This is
				usually the case if picking a power of two. If
				NativeHistogramZeroThreshold is left at zero,
				DefNativeHistogramZeroThreshold is used as the threshold. To
				configure a zero bucket with an actual threshold of zero (i.e. only
				observations of precisely zero will go into the zero bucket), set
				NativeHistogramZeroThreshold to the NativeHistogramZeroThresholdZero
				constant (or any negative float value).

			HistogramOpts.Subsystem string
			VariableLabels ConstrainableLabels
				VariableLabels are used to partition the metric vector by the given set
				of labels. Each label value will be constrained with the optional Constraint
				function, if provided.


	 type LabelConstraint (func)
		LabelConstraint normalizes label values.

	 type Labels (map)
		Labels represents a collection of label name -> value mappings. This type is
		commonly used with the With(Labels) and GetMetricWith(Labels) methods of
		metric vector Collectors, e.g.:
		
			myVec.With(Labels{"code": "404", "method": "GET"}).Add(42)
		
		The other use-case is the specification of constant label pairs in Opts or to
		create a Desc.

		As Inputs Of (at least 29)
			func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *Desc
			func WrapRegistererWith(labels Labels, reg Registerer) Registerer
			func (*CounterVec).CurryWith(labels Labels) (*CounterVec, error)
			func (*CounterVec).GetMetricWith(labels Labels) (Counter, error)
			func (*CounterVec).MustCurryWith(labels Labels) *CounterVec
			func (*CounterVec).With(labels Labels) Counter
			func ExemplarAdder.AddWithExemplar(value float64, exemplar Labels)
			func ExemplarObserver.ObserveWithExemplar(value float64, exemplar Labels)
			func (*GaugeVec).CurryWith(labels Labels) (*GaugeVec, error)
			func (*GaugeVec).GetMetricWith(labels Labels) (Gauge, error)
			func (*GaugeVec).MustCurryWith(labels Labels) *GaugeVec
			func (*GaugeVec).With(labels Labels) Gauge
			func (*HistogramVec).CurryWith(labels Labels) (ObserverVec, error)
			func (*HistogramVec).GetMetricWith(labels Labels) (Observer, error)
			func (*HistogramVec).MustCurryWith(labels Labels) ObserverVec
			func (*HistogramVec).With(labels Labels) Observer
			func (*MetricVec).CurryWith(labels Labels) (*MetricVec, error)
			func (*MetricVec).Delete(labels Labels) bool
			func (*MetricVec).DeletePartialMatch(labels Labels) int
			func (*MetricVec).GetMetricWith(labels Labels) (Metric, error)
			func ObserverVec.CurryWith(Labels) (ObserverVec, error)
			func ObserverVec.GetMetricWith(Labels) (Observer, error)
			func ObserverVec.MustCurryWith(Labels) ObserverVec
			func ObserverVec.With(Labels) Observer
			func (*SummaryVec).CurryWith(labels Labels) (ObserverVec, error)
			func (*SummaryVec).GetMetricWith(labels Labels) (Observer, error)
			func (*SummaryVec).MustCurryWith(labels Labels) ObserverVec
			func (*SummaryVec).With(labels Labels) Observer
			func (*Timer).ObserveDurationWithExemplar(exemplar Labels) time.Duration

	 type Metric (interface)
		A Metric models a single sample value with its meta data being exported to
		Prometheus. Implementations of Metric in this package are Gauge, Counter,
		Histogram, Summary, and Untyped.

		Methods (total 2)
			( Metric) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( Metric) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least 7)
			 Counter (interface)
			 CounterFunc (interface)
			 Gauge (interface)
			 GaugeFunc (interface)
			 Histogram (interface)
			 Summary (interface)
			 UntypedFunc (interface)
		As Outputs Of (at least 20)
			func MustNewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) Metric
			func MustNewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) Metric
			func MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric
			func MustNewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) Metric
			func MustNewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, nativeHistogramSchema int32, nativeHistogramZeroThreshold float64, createdTimestamp time.Time, labelValues ...string) Metric
			func MustNewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) Metric
			func MustNewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) Metric
			func MustNewMetricWithExemplars(m Metric, exemplars ...Exemplar) Metric
			func NewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) (Metric, error)
			func NewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) (Metric, error)
			func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error)
			func NewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) (Metric, error)
			func NewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, schema int32, zeroThreshold float64, createdTimestamp time.Time, labelValues ...string) (Metric, error)
			func NewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) (Metric, error)
			func NewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) (Metric, error)
			func NewInvalidMetric(desc *Desc, err error) Metric
			func NewMetricWithExemplars(m Metric, exemplars ...Exemplar) (Metric, error)
			func NewMetricWithTimestamp(t time.Time, m Metric) Metric
			func (*MetricVec).GetMetricWith(labels Labels) (Metric, error)
			func (*MetricVec).GetMetricWithLabelValues(lvs ...string) (Metric, error)
		As Inputs Of (at least 15)
			func MustNewMetricWithExemplars(m Metric, exemplars ...Exemplar) Metric
			func NewMetricWithExemplars(m Metric, exemplars ...Exemplar) (Metric, error)
			func NewMetricWithTimestamp(t time.Time, m Metric) Metric
			func Collector.Collect(chan<- Metric)
			func CollectorFunc.Collect(ch chan<- Metric)
			func Counter.Collect(chan<- Metric)
			func CounterFunc.Collect(chan<- Metric)
			func Gauge.Collect(chan<- Metric)
			func GaugeFunc.Collect(chan<- Metric)
			func Histogram.Collect(chan<- Metric)
			func (*MetricVec).Collect(ch chan<- Metric)
			func ObserverVec.Collect(chan<- Metric)
			func (*Registry).Collect(ch chan<- Metric)
			func Summary.Collect(chan<- Metric)
			func UntypedFunc.Collect(chan<- Metric)

	 type MetricVec (struct)
		MetricVec is a Collector to bundle metrics of the same name that differ in
		their label values. MetricVec is not used directly but as a building block
		for implementations of vectors of a given metric type, like GaugeVec,
		CounterVec, SummaryVec, and HistogramVec. It is exported so that it can be
		used for custom Metric implementations.
		
		To create a FooVec for custom Metric Foo, embed a pointer to MetricVec in
		FooVec and initialize it with NewMetricVec. Implement wrappers for
		GetMetricWithLabelValues and GetMetricWith that return (Foo, error) rather
		than (Metric, error). Similarly, create a wrapper for CurryWith that returns
		(*FooVec, error) rather than (*MetricVec, error). It is recommended to also
		add the convenience methods WithLabelValues, With, and MustCurryWith, which
		panic instead of returning errors. See also the MetricVec example.

		Methods (total 9)
			(*MetricVec) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*MetricVec) CurryWith(labels Labels) (*MetricVec, error)
				CurryWith returns a vector curried with the provided labels, i.e. the
				returned vector has those labels pre-set for all labeled operations performed
				on it. The cardinality of the curried vector is reduced accordingly. The
				order of the remaining labels stays the same (just with the curried labels
				taken out of the sequence – which is relevant for the
				(GetMetric)WithLabelValues methods). It is possible to curry a curried
				vector, but only with labels not yet used for currying before.
				
				The metrics contained in the MetricVec are shared between the curried and
				uncurried vectors. They are just accessed differently. Curried and uncurried
				vectors behave identically in terms of collection. Only one must be
				registered with a given registry (usually the uncurried version). The Reset
				method deletes all metrics, even if called on a curried vector.
				
				Note that CurryWith is usually not called directly but through a wrapper
				around MetricVec, implementing a vector for a specific Metric
				implementation, for example GaugeVec.

			(*MetricVec) Delete(labels Labels) bool
				Delete deletes the metric where the variable labels are the same as those
				passed in as labels. It returns true if a metric was deleted.
				
				It is not an error if the number and names of the Labels are inconsistent
				with those of the VariableLabels in Desc. However, such inconsistent Labels
				can never match an actual metric, so the method will always return false in
				that case.
				
				This method is used for the same purpose as DeleteLabelValues(...string). See
				there for pros and cons of the two methods.

			(*MetricVec) DeleteLabelValues(lvs ...string) bool
				DeleteLabelValues removes the metric where the variable labels are the same
				as those passed in as labels (same order as the VariableLabels in Desc). It
				returns true if a metric was deleted.
				
				It is not an error if the number of label values is not the same as the
				number of VariableLabels in Desc. However, such inconsistent label count can
				never match an actual metric, so the method will always return false in that
				case.
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider Delete(Labels) as an
				alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the CounterVec example.

			(*MetricVec) DeletePartialMatch(labels Labels) int
				DeletePartialMatch deletes all metrics where the variable labels contain all of those
				passed in as labels. The order of the labels does not matter.
				It returns the number of metrics deleted.
				
				Note that curried labels will never be matched if deleting from the curried vector.
				To match curried labels with DeletePartialMatch, it must be called on the base vector.

			(*MetricVec) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*MetricVec) GetMetricWith(labels Labels) (Metric, error)
				GetMetricWith returns the Metric for the given Labels map (the label names
				must match those of the variable labels in Desc). If that label map is
				accessed for the first time, a new Metric is created. Implications of
				creating a Metric without using it and keeping the Metric for later use
				are the same as for GetMetricWithLabelValues.
				
				An error is returned if the number and names of the Labels are inconsistent
				with those of the variable labels in Desc (minus any curried labels).
				
				This method is used for the same purpose as
				GetMetricWithLabelValues(...string). See there for pros and cons of the two
				methods.
				
				Note that GetMetricWith is usually not called directly but through a wrapper
				around MetricVec, implementing a vector for a specific Metric implementation,
				for example GaugeVec.

			(*MetricVec) GetMetricWithLabelValues(lvs ...string) (Metric, error)
				GetMetricWithLabelValues returns the Metric for the given slice of label
				values (same order as the variable labels in Desc). If that combination of
				label values is accessed for the first time, a new Metric is created (by
				calling the newMetric function provided during construction of the
				MetricVec).
				
				It is possible to call this method without using the returned Metric to only
				create the new Metric but leave it in its initial state.
				
				Keeping the Metric for later use is possible (and should be considered if
				performance is critical), but keep in mind that Reset, DeleteLabelValues and
				Delete can be used to delete the Metric from the MetricVec. In that case, the
				Metric will still exist, but it will not be exported anymore, even if a
				Metric with the same label values is created later.
				
				An error is returned if the number of label values is not the same as the
				number of variable labels in Desc (minus any curried labels).
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as
				an alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				
				Note that GetMetricWithLabelValues is usually not called directly but through
				a wrapper around MetricVec, implementing a vector for a specific Metric
				implementation, for example GaugeVec.

			(*MetricVec) Reset()
				Reset deletes all metrics in this vector.

		Implements (at least one exported)
			*MetricVec : Collector
		As Outputs Of (at least 2)
			func NewMetricVec(desc *Desc, newMetric func(lvs ...string) Metric) *MetricVec
			func (*MetricVec).CurryWith(labels Labels) (*MetricVec, error)

	 type MultiError ([])
		MultiError is a slice of errors implementing the error interface. It is used
		by a Gatherer to report multiple errors during MetricFamily gathering.

		Methods (total 3)
			(*MultiError) Append(err error)
				Append appends the provided error if it is not nil.

			( MultiError) Error() string
				Error formats the contained errors as a bullet point list, preceded by the
				total number of errors. Note that this results in a multi-line string.

			( MultiError) MaybeUnwrap() error
				MaybeUnwrap returns nil if len(errs) is 0. It returns the first and only
				contained error as error if len(errs is 1). In all other cases, it returns
				the MultiError directly. This is helpful for returning a MultiError in a way
				that only uses the MultiError if needed.

		Implements (at least one exported)
			 MultiError : error

	 type MultiTRegistry (struct)
		MultiTRegistry is a TransactionalGatherer that joins gathered metrics from multiple
		transactional gatherers.
		
		It is caller responsibility to ensure two registries have mutually exclusive metric families,
		no deduplication will happen.

		Methods (only one)
			(*MultiTRegistry) Gather() (mfs []*dto.MetricFamily, done func(), err error)
				Gather implements TransactionalGatherer interface.

		Implements (at least one exported)
			*MultiTRegistry : TransactionalGatherer
		As Outputs Of (at least one exported)
			func NewMultiTRegistry(tGatherers ...TransactionalGatherer) *MultiTRegistry

	 type Observer (interface)
		Observer is the interface that wraps the Observe method, which is used by
		Histogram and Summary to add observations.

		Methods (only one)
			( Observer) Observe(float64)
		Implemented By (at least 3)
			 Histogram (interface)
			 ObserverFunc
			 Summary (interface)
		As Outputs Of (at least 12)
			func (*HistogramVec).GetMetricWith(labels Labels) (Observer, error)
			func (*HistogramVec).GetMetricWithLabelValues(lvs ...string) (Observer, error)
			func (*HistogramVec).With(labels Labels) Observer
			func (*HistogramVec).WithLabelValues(lvs ...string) Observer
			func ObserverVec.GetMetricWith(Labels) (Observer, error)
			func ObserverVec.GetMetricWithLabelValues(lvs ...string) (Observer, error)
			func ObserverVec.With(Labels) Observer
			func ObserverVec.WithLabelValues(...string) Observer
			func (*SummaryVec).GetMetricWith(labels Labels) (Observer, error)
			func (*SummaryVec).GetMetricWithLabelValues(lvs ...string) (Observer, error)
			func (*SummaryVec).With(labels Labels) Observer
			func (*SummaryVec).WithLabelValues(lvs ...string) Observer
		As Inputs Of (at least one exported)
			func NewTimer(o Observer) *Timer

	 type ObserverFunc (func)
		The ObserverFunc type is an adapter to allow the use of ordinary
		functions as Observers. If f is a function with the appropriate
		signature, ObserverFunc(f) is an Observer that calls f.
		
		This adapter is usually used in connection with the Timer type, and there are
		two general use cases:
		
		The most common one is to use a Gauge as the Observer for a Timer.
		See the "Gauge" Timer example.
		
		The more advanced use case is to create a function that dynamically decides
		which Observer to use for observing the duration. See the "Complex" Timer
		example.

		Methods (only one)
			( ObserverFunc) Observe(value float64)
				Observe calls f(value). It implements Observer.

		Implements (at least one exported)
			 ObserverFunc : Observer

	 type ObserverVec (interface)
		ObserverVec is an interface implemented by `HistogramVec` and `SummaryVec`.

		Methods (total 8)
			( ObserverVec) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( ObserverVec) CurryWith(Labels) (ObserverVec, error)
			( ObserverVec) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( ObserverVec) GetMetricWith(Labels) (Observer, error)
			( ObserverVec) GetMetricWithLabelValues(lvs ...string) (Observer, error)
			( ObserverVec) MustCurryWith(Labels) ObserverVec
			( ObserverVec) With(Labels) Observer
			( ObserverVec) WithLabelValues(...string) Observer
		Implemented By (at least 2)
			*HistogramVec
			*SummaryVec
		Implements (at least one exported)
			 ObserverVec : Collector
		As Outputs Of (at least 6)
			func (*HistogramVec).CurryWith(labels Labels) (ObserverVec, error)
			func (*HistogramVec).MustCurryWith(labels Labels) ObserverVec
			func ObserverVec.CurryWith(Labels) (ObserverVec, error)
			func ObserverVec.MustCurryWith(Labels) ObserverVec
			func (*SummaryVec).CurryWith(labels Labels) (ObserverVec, error)
			func (*SummaryVec).MustCurryWith(labels Labels) ObserverVec

	 type Opts (struct)
		Opts bundles the options for creating most Metric types. Each metric
		implementation XXX has its own XXXOpts type, but in most cases, it is just
		an alias of this type (which might change when the requirement arises.)
		
		It is mandatory to set Name to a non-empty string. All other fields are
		optional and can safely be left at their zero value, although it is strongly
		encouraged to set a Help string.

		Fields (total 5)
			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			Subsystem string

	 type ProcessCollectorOpts (struct)
		ProcessCollectorOpts defines the behavior of a process metrics collector
		created with NewProcessCollector.

		Fields (total 3)
			Namespace string
				If non-empty, each of the collected metrics is prefixed by the
				provided string and an underscore ("_").

			PidFn func() (int, error)
				PidFn returns the PID of the process the collector collects metrics
				for. It is called upon each collection. By default, the PID of the
				current process is used, as determined on construction time by
				calling os.Getpid().

			ReportErrors bool
				If true, any error encountered during collection is reported as an
				invalid metric (see NewInvalidMetric). Otherwise, errors are ignored
				and the collected metrics will be incomplete. (Possibly, no metrics
				will be collected at all.) While that's usually not desired, it is
				appropriate for the common "mix-in" of process metrics, where process
				metrics are nice to have, but failing to collect them should not
				disrupt the collection of the remaining metrics.

		As Inputs Of (at least one exported)
			func NewProcessCollector(opts ProcessCollectorOpts) Collector

	 type Registerer (interface)
		Registerer is the interface for the part of a registry in charge of
		registering and unregistering. Users of custom registries should use
		Registerer as type for registration purposes (rather than the Registry type
		directly). In that way, they are free to use custom Registerer implementation
		(e.g. for testing purposes).

		Methods (total 3)
			( Registerer) MustRegister(...Collector)
				MustRegister works like Register but registers any number of
				Collectors and panics upon the first registration that causes an
				error.

			( Registerer) Register(Collector) error
				Register registers a new Collector to be included in metrics
				collection. It returns an error if the descriptors provided by the
				Collector are invalid or if they — in combination with descriptors of
				already registered Collectors — do not fulfill the consistency and
				uniqueness criteria described in the documentation of metric.Desc.
				
				If the provided Collector is equal to a Collector already registered
				(which includes the case of re-registering the same Collector), the
				returned error is an instance of AlreadyRegisteredError, which
				contains the previously registered Collector.
				
				A Collector whose Describe method does not yield any Desc is treated
				as unchecked. Registration will always succeed. No check for
				re-registering (see previous paragraph) is performed. Thus, the
				caller is responsible for not double-registering the same unchecked
				Collector, and for providing a Collector that will not cause
				inconsistent metrics on collection. (This would lead to scrape
				errors.)

			( Registerer) Unregister(Collector) bool
				Unregister unregisters the Collector that equals the Collector passed
				in as an argument.  (Two Collectors are considered equal if their
				Describe method yields the same set of descriptors.) The function
				returns whether a Collector was unregistered. Note that an unchecked
				Collector cannot be unregistered (as its Describe method does not
				yield any descriptor).
				
				Note that even after unregistering, it will not be possible to
				register a new Collector that is inconsistent with the unregistered
				Collector, e.g. a Collector collecting metrics with the same name but
				a different help string. The rationale here is that the same registry
				instance must only collect consistent metrics throughout its
				lifetime.

		Implemented By (at least one exported)
			*Registry
		As Outputs Of (at least 2)
			func WrapRegistererWith(labels Labels, reg Registerer) Registerer
			func WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer
		As Inputs Of (at least 22)
			func WrapRegistererWith(labels Labels, reg Registerer) Registerer
			func WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer
			func github.com/prometheus/client_golang/prometheus/promauto.With(r Registerer) promauto.Factory
			func github.com/libp2p/go-libp2p.PrometheusRegisterer(reg Registerer) libp2p.Option
			func github.com/libp2p/go-libp2p/p2p/host/autonat.WithRegisterer(reg Registerer) autonat.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/host/autorelay.WithRegisterer(reg Registerer) autorelay.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/host/eventbus.WithRegisterer(reg Registerer) eventbus.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/host/resource-manager.MustRegisterWith(reg Registerer)
			func github.com/libp2p/go-libp2p/p2p/metricshelper.RegisterCollectors(reg Registerer, collectors ...Collector)
			func github.com/libp2p/go-libp2p/p2p/net/swarm.WithRegisterer(reg Registerer) swarm.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/protocol/autonatv2.NewMetricsTracer(reg Registerer) autonatv2.MetricsTracer
			func github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay.WithRegisterer(reg Registerer) relay.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/protocol/holepunch.WithRegisterer(reg Registerer) holepunch.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/protocol/identify.WithRegisterer(reg Registerer) identify.MetricsTracerOption
			func github.com/libp2p/go-libp2p/p2p/transport/quicreuse.EnableMetrics(reg Registerer) quicreuse.Option
			func github.com/polarsignals/frostdb.WithRegistry(reg Registerer) frostdb.Option
			func github.com/polarsignals/frostdb/index.NewLSMMetrics(reg Registerer) *index.LSMMetrics
			func github.com/quic-go/quic-go/metrics.NewClientConnectionTracerWithRegisterer(registerer Registerer) *logging.ConnectionTracer
			func github.com/quic-go/quic-go/metrics.NewServerConnectionTracerWithRegisterer(registerer Registerer) *logging.ConnectionTracer
			func github.com/quic-go/quic-go/metrics.NewTracerWithRegisterer(registerer Registerer) *logging.Tracer
			func github.com/thanos-io/objstore.BucketMetrics(reg Registerer, name string) *objstore.Metrics
			func github.com/thanos-io/objstore.WrapWithMetrics(b objstore.Bucket, reg Registerer, name string) *objstore.metricBucket
		As Types Of (only one)
			  var DefaultRegisterer

	 type Registry (struct)
		Registry registers Prometheus collectors, collects their metrics, and gathers
		them into MetricFamilies for exposition. It implements Registerer, Gatherer,
		and Collector. The zero value is not usable. Create instances with
		NewRegistry or NewPedanticRegistry.
		
		Registry implements Collector to allow it to be used for creating groups of
		metrics. See the Grouping example for how this can be done.

		Methods (total 6)
			(*Registry) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*Registry) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*Registry) Gather() ([]*dto.MetricFamily, error)
				Gather implements Gatherer.

			(*Registry) MustRegister(cs ...Collector)
				MustRegister implements Registerer.

			(*Registry) Register(c Collector) error
				Register implements Registerer.

			(*Registry) Unregister(c Collector) bool
				Unregister implements Registerer.

		Implements (at least 3)
			*Registry : Collector
			*Registry : Gatherer
			*Registry : Registerer
		As Outputs Of (at least 2)
			func NewPedanticRegistry() *Registry
			func NewRegistry() *Registry
		As Inputs Of (at least 2)
			func github.com/pancsta/asyncmachine-go/pkg/telemetry/prometheus.BindToRegistry(metrics *prometheus.Metrics, registry *Registry)
			func github.com/pancsta/asyncmachine-go/pkg/telemetry/prometheus.(*Metrics).SetRegistry(registry *Registry)

	 type Summary (interface)
		A Summary captures individual observations from an event or sample stream and
		summarizes them in a manner similar to traditional summary statistics: 1. sum
		of observations, 2. observation count, 3. rank estimations.
		
		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 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.
		
		Note that the rank estimations cannot be aggregated in a meaningful way with
		the Prometheus query language (i.e. you cannot average or add them). If you
		need aggregatable quantiles (e.g. you want the 99th percentile latency of all
		queries served across all instances of a service), consider the Histogram
		metric type. See the Prometheus documentation for more details.
		
		To create Summary instances, use NewSummary.

		Methods (total 5)
			( Summary) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( Summary) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( Summary) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( Summary) Observe(float64)
				Observe adds a single observation to the histogram. Observations are
				usually positive or zero. Negative observations are accepted but
				prevent current versions of Prometheus from properly detecting
				counter resets in the sum of observations. (The experimental Native
				Histograms handle negative observations properly.) See
				https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations
				for details.

			( Summary) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least one exported)
			 Histogram (interface)
		Implements (at least 7)
			 Summary : Collector
			 Summary : CounterFunc
			 Summary : GaugeFunc
			 Summary : Histogram
			 Summary : Metric
			 Summary : Observer
			 Summary : UntypedFunc
		As Outputs Of (at least 3)
			func NewSummary(opts SummaryOpts) Summary
			func github.com/prometheus/client_golang/prometheus/promauto.NewSummary(opts SummaryOpts) Summary
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewSummary(opts SummaryOpts) Summary

	 type SummaryOpts (struct)
		SummaryOpts bundles the options for creating a Summary metric. It is
		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 v1.0.0 of the library.

		Fields (total 9)
			AgeBuckets uint32
				AgeBuckets is the number of buckets used to exclude observations that
				are older than MaxAge from the summary. A higher number has a
				resource penalty, so only increase it if the higher resolution is
				really required. For very high observation rates, you might want to
				reduce the number of age buckets. With only one age bucket, you will
				effectively see a complete reset of the summary each time MaxAge has
				passed. The default value is DefAgeBuckets.

			BufCap uint32
				BufCap defines the default sample stream buffer size.  The default
				value of DefBufCap should suffice for most uses. If there is a need
				to increase the value, a multiple of 500 is recommended (because that
				is the internal buffer size of the underlying package
				"github.com/bmizerany/perks/quantile").

			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				Due to the way a Summary is represented in the Prometheus text format
				and how it is handled by the Prometheus server internally, “quantile”
				is an illegal label name. Construction of a Summary or SummaryVec
				will panic if this label name is used in ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this Summary.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			MaxAge time.Duration
				MaxAge defines the duration for which an observation stays relevant
				for the summary. Only applies to pre-calculated quantiles, does not
				apply to _sum and _count. Must be positive. The default value is
				DefMaxAge.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Summary (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the Summary must be a
				valid Prometheus metric name.

			Objectives map[float64]float64
				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 an empty map, resulting in a summary without
				quantiles.

			Subsystem string
		As Inputs Of (at least 6)
			func NewSummary(opts SummaryOpts) Summary
			func NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewSummary(opts SummaryOpts) Summary
			func github.com/prometheus/client_golang/prometheus/promauto.NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewSummary(opts SummaryOpts) Summary
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec

	 type SummaryVec (struct)
		SummaryVec is a Collector that bundles a set of Summaries 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
		(e.g. HTTP request latencies, partitioned by status code and method). Create
		instances with NewSummaryVec.

		Fields (only one)
			MetricVec *MetricVec
		Methods (total 12)
			( SummaryVec) Collect(ch chan<- Metric)
				Collect implements Collector.

			(*SummaryVec) CurryWith(labels Labels) (ObserverVec, error)
				CurryWith returns a vector curried with the provided labels, i.e. the
				returned vector has those labels pre-set for all labeled operations performed
				on it. The cardinality of the curried vector is reduced accordingly. The
				order of the remaining labels stays the same (just with the curried labels
				taken out of the sequence – which is relevant for the
				(GetMetric)WithLabelValues methods). It is possible to curry a curried
				vector, but only with labels not yet used for currying before.
				
				The metrics contained in the SummaryVec are shared between the curried and
				uncurried vectors. They are just accessed differently. Curried and uncurried
				vectors behave identically in terms of collection. Only one must be
				registered with a given registry (usually the uncurried version). The Reset
				method deletes all metrics, even if called on a curried vector.

			( SummaryVec) Delete(labels Labels) bool
				Delete deletes the metric where the variable labels are the same as those
				passed in as labels. It returns true if a metric was deleted.
				
				It is not an error if the number and names of the Labels are inconsistent
				with those of the VariableLabels in Desc. However, such inconsistent Labels
				can never match an actual metric, so the method will always return false in
				that case.
				
				This method is used for the same purpose as DeleteLabelValues(...string). See
				there for pros and cons of the two methods.

			( SummaryVec) DeleteLabelValues(lvs ...string) bool
				DeleteLabelValues removes the metric where the variable labels are the same
				as those passed in as labels (same order as the VariableLabels in Desc). It
				returns true if a metric was deleted.
				
				It is not an error if the number of label values is not the same as the
				number of VariableLabels in Desc. However, such inconsistent label count can
				never match an actual metric, so the method will always return false in that
				case.
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider Delete(Labels) as an
				alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the CounterVec example.

			( SummaryVec) DeletePartialMatch(labels Labels) int
				DeletePartialMatch deletes all metrics where the variable labels contain all of those
				passed in as labels. The order of the labels does not matter.
				It returns the number of metrics deleted.
				
				Note that curried labels will never be matched if deleting from the curried vector.
				To match curried labels with DeletePartialMatch, it must be called on the base vector.

			( SummaryVec) Describe(ch chan<- *Desc)
				Describe implements Collector.

			(*SummaryVec) GetMetricWith(labels Labels) (Observer, error)
				GetMetricWith returns the Summary for the given Labels map (the label names
				must match those of the variable labels in Desc). If that label map is
				accessed for the first time, a new Summary is created. Implications of
				creating a Summary without using it and keeping the Summary for later use are
				the same as for GetMetricWithLabelValues.
				
				An error is returned if the number and names of the Labels are inconsistent
				with those of the variable labels in Desc (minus any curried labels).
				
				This method is used for the same purpose as
				GetMetricWithLabelValues(...string). See there for pros and cons of the two
				methods.

			(*SummaryVec) GetMetricWithLabelValues(lvs ...string) (Observer, error)
				GetMetricWithLabelValues returns the Summary for the given slice of label
				values (same order as the variable labels in Desc). If that combination of
				label values is accessed for the first time, a new Summary is created.
				
				It is possible to call this method without using the returned Summary to only
				create the new Summary but leave it at its starting value, a Summary without
				any observations.
				
				Keeping the Summary for later use is possible (and should be considered if
				performance is critical), but keep in mind that Reset, DeleteLabelValues and
				Delete can be used to delete the Summary from the SummaryVec. In that case,
				the Summary will still exist, but it will not be exported anymore, even if a
				Summary with the same label values is created later. See also the CounterVec
				example.
				
				An error is returned if the number of label values is not the same as the
				number of variable labels in Desc (minus any curried labels).
				
				Note that for more than one label value, this method is prone to mistakes
				caused by an incorrect order of arguments. Consider GetMetricWith(Labels) as
				an alternative to avoid that type of mistake. For higher label numbers, the
				latter has a much more readable (albeit more verbose) syntax, but it comes
				with a performance overhead (for creating and processing the Labels map).
				See also the GaugeVec example.

			(*SummaryVec) MustCurryWith(labels Labels) ObserverVec
				MustCurryWith works as CurryWith but panics where CurryWith would have
				returned an error.

			( SummaryVec) Reset()
				Reset deletes all metrics in this vector.

			(*SummaryVec) With(labels Labels) Observer
				With works as GetMetricWith, but panics where GetMetricWithLabels would have
				returned an error. Not returning an error allows shortcuts like
				
					myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Observe(42.21)

			(*SummaryVec) WithLabelValues(lvs ...string) Observer
				WithLabelValues works as GetMetricWithLabelValues, but panics where
				GetMetricWithLabelValues would have returned an error. Not returning an
				error allows shortcuts like
				
					myVec.WithLabelValues("404", "GET").Observe(42.21)

		Implements (at least 2)
			 SummaryVec : Collector
			*SummaryVec : ObserverVec
		As Outputs Of (at least 3)
			func NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec
			func github.com/prometheus/client_golang/prometheus/promauto.NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec

	 type SummaryVecOpts (struct)
		SummaryVecOpts bundles the options to create a SummaryVec metric.
		It is mandatory to set SummaryOpts, see there for mandatory fields. VariableLabels
		is optional and can safely be left to its default value.

		Fields (total 11)
			SummaryOpts SummaryOpts
			SummaryOpts.AgeBuckets uint32
				AgeBuckets is the number of buckets used to exclude observations that
				are older than MaxAge from the summary. A higher number has a
				resource penalty, so only increase it if the higher resolution is
				really required. For very high observation rates, you might want to
				reduce the number of age buckets. With only one age bucket, you will
				effectively see a complete reset of the summary each time MaxAge has
				passed. The default value is DefAgeBuckets.

			SummaryOpts.BufCap uint32
				BufCap defines the default sample stream buffer size.  The default
				value of DefBufCap should suffice for most uses. If there is a need
				to increase the value, a multiple of 500 is recommended (because that
				is the internal buffer size of the underlying package
				"github.com/bmizerany/perks/quantile").

			SummaryOpts.ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				Due to the way a Summary is represented in the Prometheus text format
				and how it is handled by the Prometheus server internally, “quantile”
				is an illegal label name. Construction of a Summary or SummaryVec
				will panic if this label name is used in ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			SummaryOpts.Help string
				Help provides information about this Summary.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			SummaryOpts.MaxAge time.Duration
				MaxAge defines the duration for which an observation stays relevant
				for the summary. Only applies to pre-calculated quantiles, does not
				apply to _sum and _count. Must be positive. The default value is
				DefMaxAge.

			SummaryOpts.Name string
			SummaryOpts.Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Summary (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the Summary must be a
				valid Prometheus metric name.

			SummaryOpts.Objectives map[float64]float64
				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 an empty map, resulting in a summary without
				quantiles.

			SummaryOpts.Subsystem string
			VariableLabels ConstrainableLabels
				VariableLabels are used to partition the metric vector by the given set
				of labels. Each label value will be constrained with the optional Constraint
				function, if provided.


	 type Timer (struct)
		Timer is a helper type to time functions. Use NewTimer to create new
		instances.

		Methods (total 2)
			(*Timer) ObserveDuration() time.Duration
				ObserveDuration records the duration passed since the Timer was created with
				NewTimer. It calls the Observe method of the Observer provided during
				construction with the duration in seconds as an argument. The observed
				duration is also returned. ObserveDuration is usually called with a defer
				statement.
				
				Note that this method is only guaranteed to never observe negative durations
				if used with Go1.9+.

			(*Timer) ObserveDurationWithExemplar(exemplar Labels) time.Duration
				ObserveDurationWithExemplar is like ObserveDuration, but it will also
				observe exemplar with the duration unless exemplar is nil or provided Observer can't
				be casted to ExemplarObserver.

		As Outputs Of (at least one exported)
			func NewTimer(o Observer) *Timer

	 type TransactionalGatherer (interface)
		TransactionalGatherer represents transactional gatherer that can be triggered to notify gatherer that memory
		used by metric family is no longer used by a caller. This allows implementations with cache.

		Methods (only one)
			( TransactionalGatherer) Gather() (_ []*dto.MetricFamily, done func(), err error)
				Gather returns metrics in a lexicographically sorted slice
				of uniquely named MetricFamily protobufs. Gather ensures that the
				returned slice is valid and self-consistent so that it can be used
				for valid exposition. As an exception to the strict consistency
				requirements described for metric.Desc, Gather will tolerate
				different sets of label names for metrics of the same metric family.
				
				Even if an error occurs, Gather attempts to gather as many metrics as
				possible. Hence, if a non-nil error is returned, the returned
				MetricFamily slice could be nil (in case of a fatal error that
				prevented any meaningful metric collection) or contain a number of
				MetricFamily protobufs, some of which might be incomplete, and some
				might be missing altogether. The returned error (which might be a
				MultiError) explains the details. Note that this is mostly useful for
				debugging purposes. If the gathered protobufs are to be used for
				exposition in actual monitoring, it is almost always better to not
				expose an incomplete result and instead disregard the returned
				MetricFamily protobufs in case the returned error is non-nil.
				
				Important: done is expected to be triggered (even if the error occurs!)
				once caller does not need returned slice of dto.MetricFamily.

		Implemented By (at least one exported)
			*MultiTRegistry
		As Outputs Of (at least one exported)
			func ToTransactionalGatherer(g Gatherer) TransactionalGatherer
		As Inputs Of (at least one exported)
			func NewMultiTRegistry(tGatherers ...TransactionalGatherer) *MultiTRegistry

	 type UnconstrainedLabels ([])
		UnconstrainedLabels represents collection of label without any constraint on
		their value. Thus, it is simply a collection of label names.
		
			UnconstrainedLabels([]string{ "A", "B" })
		
		is equivalent to
		
			ConstrainedLabels {
			  { Name: "A" },
			  { Name: "B" },
			}

		Implements (at least one exported)
			 UnconstrainedLabels : ConstrainableLabels

	 type UntypedFunc (interface)
		UntypedFunc works like GaugeFunc but the collected metric is of type
		"Untyped". UntypedFunc is useful to mirror an external metric of unknown
		type.
		
		To create UntypedFunc instances, use NewUntypedFunc.

		Methods (total 4)
			( UntypedFunc) Collect(chan<- Metric)
				Collect is called by the Prometheus registry when collecting
				metrics. The implementation sends each collected metric via the
				provided channel and returns once the last metric has been sent. The
				descriptor of each sent metric is one of those returned by Describe
				(unless the Collector is unchecked, see above). Returned metrics that
				share the same descriptor must differ in their variable label
				values.
				
				This method may be called concurrently and must therefore be
				implemented in a concurrency safe way. Blocking occurs at the expense
				of total performance of rendering all registered metrics. Ideally,
				Collector implementations support concurrent readers.

			( UntypedFunc) Desc() *Desc
				Desc returns the descriptor for the Metric. This method idempotently
				returns the same descriptor throughout the lifetime of the
				Metric. The returned descriptor is immutable by contract. A Metric
				unable to describe itself must return an invalid descriptor (created
				with NewInvalidDesc).

			( UntypedFunc) Describe(chan<- *Desc)
				Describe sends the super-set of all possible descriptors of metrics
				collected by this Collector to the provided channel and returns once
				the last descriptor has been sent. The sent descriptors fulfill the
				consistency and uniqueness requirements described in the Desc
				documentation.
				
				It is valid if one and the same Collector sends duplicate
				descriptors. Those duplicates are simply ignored. However, two
				different Collectors must not send duplicate descriptors.
				
				Sending no descriptor at all marks the Collector as “unchecked”,
				i.e. no checks will be performed at registration time, and the
				Collector may yield any Metric it sees fit in its Collect method.
				
				This method idempotently sends the same descriptors throughout the
				lifetime of the Collector. It may be called concurrently and
				therefore must be implemented in a concurrency safe way.
				
				If a Collector encounters an error while executing this method, it
				must send an invalid descriptor (created with NewInvalidDesc) to
				signal the error to the registry.

			( UntypedFunc) Write(*dto.Metric) error
				Write encodes the Metric into a "Metric" Protocol Buffer data
				transmission object.
				
				Metric implementations must observe concurrency safety as reads of
				this metric may occur at any time, and any blocking occurs at the
				expense of total performance of rendering all registered
				metrics. Ideally, Metric implementations should support concurrent
				readers.
				
				While populating dto.Metric, it is the responsibility of the
				implementation to ensure validity of the Metric protobuf (like valid
				UTF-8 strings or syntactically valid metric and label names). It is
				recommended to sort labels lexicographically. Callers of Write should
				still make sure of sorting if they depend on it.

		Implemented By (at least 6)
			 Counter (interface)
			 CounterFunc (interface)
			 Gauge (interface)
			 GaugeFunc (interface)
			 Histogram (interface)
			 Summary (interface)
		Implements (at least 4)
			 UntypedFunc : Collector
			 UntypedFunc : CounterFunc
			 UntypedFunc : GaugeFunc
			 UntypedFunc : Metric
		As Outputs Of (at least 3)
			func NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc

	 type UntypedOpts Opts (struct)
		UntypedOpts is an alias for Opts. See there for doc comments.

		Fields (total 5)
			ConstLabels Labels
				ConstLabels are used to attach fixed labels to this metric. Metrics
				with the same fully-qualified name must have the same label names in
				their ConstLabels.
				
				ConstLabels are only used rarely. In particular, do not use them to
				attach the same labels to all your metrics. Those use cases are
				better covered by target labels set by the scraping Prometheus
				server, or by one specific metric (e.g. a build_info or a
				machine_role metric). See also
				https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels

			Help string
				Help provides information about this metric.
				
				Metrics with the same fully-qualified name must have the same Help
				string.

			Name string
			Namespace string
				Namespace, Subsystem, and Name are components of the fully-qualified
				name of the Metric (created by joining these components with
				"_"). Only Name is mandatory, the others merely help structuring the
				name. Note that the fully-qualified name of the metric must be a
				valid Prometheus metric name.

			Subsystem string
		As Inputs Of (at least 3)
			func NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc
			func github.com/prometheus/client_golang/prometheus/promauto.NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc
			func github.com/prometheus/client_golang/prometheus/promauto.Factory.NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc

	 type ValueType int (basic type)
		ValueType is an enumeration of metric types that represent a simple value.

		Methods (only one)
			( ValueType) ToDTO() *dto.MetricType
		As Inputs Of (at least 4)
			func MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric
			func MustNewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) Metric
			func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error)
			func NewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) (Metric, error)
		As Types Of (total 3)
			const CounterValue
			const GaugeValue
			const UntypedValue


Package-Level Functions (total 54)

	 func BuildFQName(namespace, subsystem, name string) string
		BuildFQName joins the given three name components by "_". Empty name
		components are ignored. If the name parameter itself is empty, an empty
		string is returned, no matter what. Metric implementations included in this
		library use this function internally to generate the fully-qualified metric
		name from the name component in their Opts. Users of the library will only
		need this function if they implement their own Metric or instantiate a Desc
		(with NewDesc) directly.

	 func DescribeByCollect(c Collector, descs chan<- *Desc)
		DescribeByCollect is a helper to implement the Describe method of a custom
		Collector. It collects the metrics from the provided Collector and sends
		their descriptors to the provided channel.
		
		If a Collector collects the same metrics throughout its lifetime, its
		Describe method can simply be implemented as:
		
			func (c customCollector) Describe(ch chan<- *Desc) {
				DescribeByCollect(c, ch)
			}
		
		However, this will not work if the metrics collected change dynamically over
		the lifetime of the Collector in a way that their combined set of descriptors
		changes as well. The shortcut implementation will then violate the contract
		of the Describe method. If a Collector sometimes collects no metrics at all
		(for example vectors like CounterVec, GaugeVec, etc., which only collect
		metrics after a metric with a fully specified label set has been accessed),
		it might even get registered as an unchecked 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.
		
		The Collector example demonstrates a use of DescribeByCollect.

	 func ExponentialBuckets(start, factor float64, count int) []float64
		ExponentialBuckets creates 'count' regular buckets, where the lowest bucket
		has an upper bound of 'start' and each following bucket's upper bound is
		'factor' times the previous bucket's upper bound. The final +Inf bucket is
		not counted and not included in the returned slice. The returned slice is
		meant to be used for the Buckets field of HistogramOpts.
		
		The function panics if 'count' is 0 or negative, if 'start' is 0 or negative,
		or if 'factor' is less than or equal 1.

	 func ExponentialBucketsRange(minBucket, maxBucket float64, count int) []float64
		ExponentialBucketsRange creates 'count' buckets, where the lowest bucket is
		'min' and the highest bucket is 'max'. The final +Inf bucket is not counted
		and not included in the returned slice. The returned slice is meant to be
		used for the Buckets field of HistogramOpts.
		
		The function panics if 'count' is 0 or negative, if 'min' is 0 or negative.

	 func LinearBuckets(start, width float64, count int) []float64
		LinearBuckets creates 'count' regular buckets, each 'width' wide, where the
		lowest bucket has an upper bound of 'start'. The final +Inf bucket is not
		counted and not included in the returned slice. The returned slice is meant
		to be used for the Buckets field of HistogramOpts.
		
		The function panics if 'count' is zero or negative.

	 func MakeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair
		MakeLabelPairs is a helper function to create protobuf LabelPairs from the
		variable and constant labels in the provided Desc. The values for the
		variable labels are defined by the labelValues slice, which must be in the
		same order as the corresponding variable labels in the Desc.
		
		This function is only needed for custom Metric implementations. See MetricVec
		example.

	 func MustNewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) Metric
		MustNewConstHistogram is a version of NewConstHistogram that panics where
		NewConstHistogram would have returned an error.

	 func MustNewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) Metric
		MustNewConstHistogramWithCreatedTimestamp is a version of NewConstHistogramWithCreatedTimestamp that panics where
		NewConstHistogramWithCreatedTimestamp would have returned an error.

	 func MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric
		MustNewConstMetric is a version of NewConstMetric that panics where
		NewConstMetric would have returned an error.

	 func MustNewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) Metric
		MustNewConstMetricWithCreatedTimestamp is a version of NewConstMetricWithCreatedTimestamp that panics where
		NewConstMetricWithCreatedTimestamp would have returned an error.

	 func MustNewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, nativeHistogramSchema int32, nativeHistogramZeroThreshold float64, createdTimestamp time.Time, labelValues ...string) Metric
		MustNewConstNativeHistogram is a version of NewConstNativeHistogram that panics where
		NewConstNativeHistogram would have returned an error.

	 func MustNewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) Metric
		MustNewConstSummary is a version of NewConstSummary that panics where
		NewConstMetric would have returned an error.

	 func MustNewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) Metric
		MustNewConstSummaryWithCreatedTimestamp is a version of NewConstSummaryWithCreatedTimestamp that panics where
		NewConstSummaryWithCreatedTimestamp would have returned an error.

	 func MustNewMetricWithExemplars(m Metric, exemplars ...Exemplar) Metric
		MustNewMetricWithExemplars is a version of NewMetricWithExemplars that panics where
		NewMetricWithExemplars would have returned an error.

	 func MustRegister(cs ...Collector)
		MustRegister registers the provided Collectors with the DefaultRegisterer and
		panics if any error occurs.
		
		MustRegister is a shortcut for DefaultRegisterer.MustRegister(cs...). See
		there for more details.

	 func NewBuildInfoCollector() Collector
		NewBuildInfoCollector is the obsolete version of collectors.NewBuildInfoCollector.
		See there for documentation.
		
		Deprecated: Use collectors.NewBuildInfoCollector instead.

	 func NewConstHistogram(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, labelValues ...string) (Metric, error)
		NewConstHistogram returns a metric representing a Prometheus histogram with
		fixed values for the count, sum, and bucket counts. As those parameters
		cannot be changed, the returned value does not implement the Histogram
		interface (but only the Metric interface). Users of this package will not
		have much use for it in regular operations. However, when implementing custom
		Collectors, it is useful as a throw-away metric that is generated on the fly
		to send it to Prometheus in the Collect method.
		
		buckets is a map of upper bounds to cumulative counts, excluding the +Inf
		bucket. The +Inf bucket is implicit, and its value is equal to the provided count.
		
		NewConstHistogram returns an error if the length of labelValues is not
		consistent with the variable labels in Desc or if Desc is invalid.

	 func NewConstHistogramWithCreatedTimestamp(desc *Desc, count uint64, sum float64, buckets map[float64]uint64, ct time.Time, labelValues ...string) (Metric, error)
		NewConstHistogramWithCreatedTimestamp does the same thing as NewConstHistogram but sets the created timestamp.

	 func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error)
		NewConstMetric returns a metric with one fixed value that cannot be
		changed. Users of this package will not have much use for it in regular
		operations. However, when implementing custom Collectors, it is useful as a
		throw-away metric that is generated on the fly to send it to Prometheus in
		the Collect method. NewConstMetric returns an error if the length of
		labelValues is not consistent with the variable labels in Desc or if Desc is
		invalid.

	 func NewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) (Metric, error)
		NewConstMetricWithCreatedTimestamp does the same thing as NewConstMetric, but generates Counters
		with created timestamp set and returns an error for other metric types.

	 func NewConstNativeHistogram(desc *Desc, count uint64, sum float64, positiveBuckets, negativeBuckets map[int]int64, zeroBucket uint64, schema int32, zeroThreshold float64, createdTimestamp time.Time, labelValues ...string) (Metric, error)
		NewConstNativeHistogram returns a metric representing a Prometheus native histogram with
		fixed values for the count, sum, and positive/negative/zero bucket counts. As those parameters
		cannot be changed, the returned value does not implement the Histogram
		interface (but only the Metric interface). Users of this package will not
		have much use for it in regular operations. However, when implementing custom
		OpenTelemetry Collectors, it is useful as a throw-away metric that is generated on the fly
		to send it to Prometheus in the Collect method.
		
		zeroBucket counts all (positive and negative)
		observations in the zero bucket (with an absolute value less or equal
		the current threshold).
		positiveBuckets and negativeBuckets are separate maps for negative and positive
		observations. The map's value is an int64, counting observations in
		that bucket. The map's key is the
		index of the bucket according to the used
		Schema. Index 0 is for an upper bound of 1 in positive buckets and for a lower bound of -1 in negative buckets.
		NewConstNativeHistogram returns an error if
		  - the length of labelValues is not consistent with the variable labels in Desc or if Desc is invalid.
		  - the schema passed is not between 8 and -4
		  - the sum of counts in all buckets including the zero bucket does not equal the count if sum is not NaN (or exceeds the count if sum is NaN)
		
		See https://opentelemetry.io/docs/specs/otel/compatibility/prometheus_and_openmetrics/#exponential-histograms for more details about the conversion from OTel to Prometheus.

	 func NewConstSummary(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, labelValues ...string) (Metric, error)
		NewConstSummary returns a metric representing a Prometheus summary with fixed
		values for the count, sum, and quantiles. As those parameters cannot be
		changed, the returned value does not implement the Summary interface (but
		only the Metric interface). Users of this package will not have much use for
		it in regular operations. However, when implementing custom Collectors, it is
		useful as a throw-away metric that is generated on the fly to send it to
		Prometheus in the Collect method.
		
		quantiles maps ranks to quantile values. For example, a median latency of
		0.23s and a 99th percentile latency of 0.56s would be expressed as:
		
			map[float64]float64{0.5: 0.23, 0.99: 0.56}
		
		NewConstSummary returns an error if the length of labelValues is not
		consistent with the variable labels in Desc or if Desc is invalid.

	 func NewConstSummaryWithCreatedTimestamp(desc *Desc, count uint64, sum float64, quantiles map[float64]float64, ct time.Time, labelValues ...string) (Metric, error)
		NewConstSummaryWithCreatedTimestamp does the same thing as NewConstSummary but sets the created timestamp.

	 func NewCounter(opts CounterOpts) Counter
		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
		as a uint64. This allows atomic increments of the counter with optimal
		performance. (It is common to have an Inc call in very hot execution paths.)
		Both internal tracking values are added up in the Write method. This has to
		be taken into account when it comes to precision and overflow behavior.

	 func NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc
		NewCounterFunc creates a new CounterFunc based on the provided
		CounterOpts. The value reported is determined by calling the given function
		from within the Write method. Take into account that metric collection may
		happen concurrently. If that results in concurrent calls to Write, like in
		the case where a CounterFunc is directly registered with Prometheus, the
		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 NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec
		NewCounterVec creates a new CounterVec based on the provided CounterOpts and
		partitioned by the given label names.

	 func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *Desc
		NewDesc allocates and initializes a new Desc. Errors are recorded in the Desc
		and will be reported on registration time. variableLabels and constLabels can
		be nil if no such labels should be set. fqName must not be empty.
		
		variableLabels only contain the label names. Their label values are variable
		and therefore not part of the Desc. (They are managed within the Metric.)
		
		For constLabels, the label values are constant. Therefore, they are fully
		specified in the Desc. See the Collector example for a usage pattern.

	 func NewExpvarCollector(exports map[string]*Desc) Collector
		NewExpvarCollector is the obsolete version of collectors.NewExpvarCollector.
		See there for documentation.
		
		Deprecated: Use collectors.NewExpvarCollector instead.

	 func NewGauge(opts GaugeOpts) Gauge
		NewGauge creates a new Gauge based on the provided GaugeOpts.
		
		The returned implementation is optimized for a fast Set method. If you have a
		choice for managing the value of a Gauge via Set vs. Inc/Dec/Add/Sub, pick
		the former. For example, the Inc method of the returned Gauge is slower than
		the Inc method of a Counter returned by NewCounter. This matches the typical
		scenarios for Gauges and Counters, where the former tends to be Set-heavy and
		the latter Inc-heavy.

	 func NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc
		NewGaugeFunc creates a new GaugeFunc based on the provided GaugeOpts. The
		value reported is determined by calling the given function from within the
		Write method. Take into account that metric collection may happen
		concurrently. Therefore, it must be safe to call the provided function
		concurrently.
		
		NewGaugeFunc is a good way to create an “info” style metric with a constant
		value of 1. Example:
		https://github.com/prometheus/common/blob/8558a5b7db3c84fa38b4766966059a7bd5bfa2ee/version/info.go#L36-L56

	 func NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec
		NewGaugeVec creates a new GaugeVec based on the provided GaugeOpts and
		partitioned by the given label names.

	 func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector
		NewGoCollector is the obsolete version of collectors.NewGoCollector.
		See there for documentation.
		
		Deprecated: Use collectors.NewGoCollector instead.

	 func NewHistogram(opts HistogramOpts) Histogram
		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 NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec
		NewHistogramVec creates a new HistogramVec based on the provided HistogramOpts and
		partitioned by the given label names.

	 func NewInvalidDesc(err error) *Desc
		NewInvalidDesc returns an invalid descriptor, i.e. a descriptor with the
		provided error set. If a collector returning such a descriptor is registered,
		registration will fail with the provided error. NewInvalidDesc can be used by
		a Collector to signal inability to describe itself.

	 func NewInvalidMetric(desc *Desc, err error) Metric
		NewInvalidMetric returns a metric whose Write method always returns the
		provided error. It is useful if a Collector finds itself unable to collect
		a metric and wishes to report an error to the registry.

	 func NewMetricVec(desc *Desc, newMetric func(lvs ...string) Metric) *MetricVec
		NewMetricVec returns an initialized metricVec.

	 func NewMetricWithExemplars(m Metric, exemplars ...Exemplar) (Metric, error)
		NewMetricWithExemplars returns a new Metric wrapping the provided Metric with given
		exemplars. Exemplars are validated.
		
		Only last applicable exemplar is injected from the list.
		For example for Counter it means last exemplar is injected.
		For Histogram, it means last applicable exemplar for each bucket is injected.
		
		NewMetricWithExemplars works best with MustNewConstMetric and
		MustNewConstHistogram, see example.

	 func NewMetricWithTimestamp(t time.Time, m Metric) Metric
		NewMetricWithTimestamp returns a new Metric wrapping the provided Metric in a
		way that it has an explicit timestamp set to the provided Time. This is only
		useful in rare cases as the timestamp of a Prometheus metric should usually
		be set by the Prometheus server during scraping. Exceptions include mirroring
		metrics with given timestamps from other metric
		sources.
		
		NewMetricWithTimestamp works best with MustNewConstMetric,
		MustNewConstHistogram, and MustNewConstSummary, see example.
		
		Currently, the exposition formats used by Prometheus are limited to
		millisecond resolution. Thus, the provided time will be rounded down to the
		next full millisecond value.

	 func NewMultiTRegistry(tGatherers ...TransactionalGatherer) *MultiTRegistry
		NewMultiTRegistry creates MultiTRegistry.

	 func NewPedanticRegistry() *Registry
		NewPedanticRegistry returns a registry that checks during collection if each
		collected Metric is consistent with its reported Desc, and if the Desc has
		actually been registered with the registry. Unchecked Collectors (those whose
		Describe method does not yield any descriptors) are excluded from the check.
		
		Usually, a Registry will be happy as long as the union of all collected
		Metrics is consistent and valid even if some metrics are not consistent with
		their own Desc or a Desc provided by their registered Collector. Well-behaved
		Collectors and Metrics will only provide consistent Descs. This Registry is
		useful to test the implementation of Collectors and Metrics.

	 func NewPidFileFn(pidFilePath string) func() (int, error)
		NewPidFileFn returns a function that retrieves a pid from the specified file.
		It is meant to be used for the PidFn field in ProcessCollectorOpts.

	 func NewProcessCollector(opts ProcessCollectorOpts) Collector
		NewProcessCollector is the obsolete version of collectors.NewProcessCollector.
		See there for documentation.
		
		Deprecated: Use collectors.NewProcessCollector instead.

	 func NewRegistry() *Registry
		NewRegistry creates a new vanilla Registry without any Collectors
		pre-registered.

	 func NewSummary(opts SummaryOpts) Summary
		NewSummary creates a new Summary based on the provided SummaryOpts.

	 func NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec
		NewSummaryVec creates a new SummaryVec based on the provided SummaryOpts and
		partitioned by the given label names.
		
		Due to the way a Summary is represented in the Prometheus text format and how
		it is handled by the Prometheus server internally, “quantile” is an illegal
		label name. NewSummaryVec will panic if this label name is used.

	 func NewTimer(o Observer) *Timer
		NewTimer creates a new Timer. The provided Observer is used to observe a
		duration in seconds. If the Observer implements ExemplarObserver, passing exemplar
		later on will be also supported.
		Timer is usually used to time a function call in the
		following way:
		
			func TimeMe() {
			    timer := NewTimer(myHistogram)
			    defer timer.ObserveDuration()
			    // Do actual work.
			}
		
		or
		
			func TimeMeWithExemplar() {
				    timer := NewTimer(myHistogram)
				    defer timer.ObserveDurationWithExemplar(exemplar)
				    // Do actual work.
				}

	 func NewUntypedFunc(opts UntypedOpts, function func() float64) UntypedFunc
		NewUntypedFunc creates a new UntypedFunc based on the provided
		UntypedOpts. The value reported is determined by calling the given function
		from within the Write method. Take into account that metric collection may
		happen concurrently. If that results in concurrent calls to Write, like in
		the case where an UntypedFunc is directly registered with Prometheus, the
		provided function must be concurrency-safe.

	 func Register(c Collector) error
		Register registers the provided Collector with the DefaultRegisterer.
		
		Register is a shortcut for DefaultRegisterer.Register(c). See there for more
		details.

	 func ToTransactionalGatherer(g Gatherer) TransactionalGatherer
		ToTransactionalGatherer transforms Gatherer to transactional one with noop as done function.

	 func Unregister(c Collector) bool
		Unregister removes the registration of the provided Collector from the
		DefaultRegisterer.
		
		Unregister is a shortcut for DefaultRegisterer.Unregister(c). See there for
		more details.

	 func WrapRegistererWith(labels Labels, reg Registerer) Registerer
		WrapRegistererWith returns a Registerer wrapping the provided
		Registerer. Collectors registered with the returned Registerer will be
		registered with the wrapped Registerer in a modified way. The modified
		Collector adds the provided Labels to all Metrics it collects (as
		ConstLabels). The Metrics collected by the unmodified Collector must not
		duplicate any of those labels. Wrapping a nil value is valid, resulting
		in a no-op Registerer.
		
		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. See also
		https://prometheus.io/docs/instrumenting/writing_exporters/#target-labels-not-static-scraped-labels
		
		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 WrapRegistererWithPrefix(prefix string, reg Registerer) Registerer
		WrapRegistererWithPrefix returns a Registerer wrapping the provided
		Registerer. Collectors registered with the returned Registerer will be
		registered with the wrapped Registerer in a modified way. The modified
		Collector adds the provided prefix to the name of all Metrics it collects.
		Wrapping a nil value is valid, resulting in a no-op Registerer.
		
		WrapRegistererWithPrefix is useful to have one place to prefix all metrics of
		a sub-system. To make this work, register metrics of the sub-system with the
		wrapping Registerer returned by WrapRegistererWithPrefix. It is rarely useful
		to use the same prefix for all metrics exposed. In particular, do not prefix
		metric names that are standardized across applications, as that would break
		horizontal monitoring, for example the metrics provided by the Go collector
		(see NewGoCollector) and the process collector (see NewProcessCollector). (In
		fact, those metrics are already prefixed with “go_” or “process_”,
		respectively.)
		
		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 WriteToTextfile(filename string, g Gatherer) error
		WriteToTextfile calls Gather on the provided Gatherer, encodes the result in the
		Prometheus text format, and writes it to a temporary file. Upon success, the
		temporary file is renamed to the provided filename.
		
		This is intended for use with the textfile collector of the node exporter.
		Note that the node exporter expects the filename to be suffixed with ".prom".


Package-Level Variables (total 7)

	  var CounterMetricTypePtr *io_prometheus_client.MetricType
	  var DefaultGatherer Gatherer
		DefaultRegisterer and DefaultGatherer are the implementations of the
		Registerer and Gatherer interface a number of convenience functions in this
		package act on. Initially, both variables point to the same Registry, which
		has a process collector (currently on Linux only, see NewProcessCollector)
		and a Go collector (see NewGoCollector, in particular the note about
		stop-the-world implication with Go versions older than 1.9) already
		registered. This approach to keep default instances as global state mirrors
		the approach of other packages in the Go standard library. Note that there
		are caveats. Change the variables with caution and only if you understand the
		consequences. Users who want to avoid global state altogether should not use
		the convenience functions and act on custom instances instead.

	  var DefaultRegisterer Registerer
		DefaultRegisterer and DefaultGatherer are the implementations of the
		Registerer and Gatherer interface a number of convenience functions in this
		package act on. Initially, both variables point to the same Registry, which
		has a process collector (currently on Linux only, see NewProcessCollector)
		and a Go collector (see NewGoCollector, in particular the note about
		stop-the-world implication with Go versions older than 1.9) already
		registered. This approach to keep default instances as global state mirrors
		the approach of other packages in the Go standard library. Note that there
		are caveats. Change the variables with caution and only if you understand the
		consequences. Users who want to avoid global state altogether should not use
		the convenience functions and act on custom instances instead.

	  var DefBuckets []float64
		DefBuckets are the default Histogram buckets. The default buckets are
		tailored to broadly measure the response time (in seconds) of a network
		service. Most likely, however, you will be required to define buckets
		customized to your use case.

	  var GaugeMetricTypePtr *io_prometheus_client.MetricType
	  var UntypedMetricTypePtr *io_prometheus_client.MetricType
	  var V2 v2
		V2 is a struct that can be referenced to access experimental API that might
		be present in v2 of client golang someday. It offers extended functionality
		of v1 with slightly changed API. It is acceptable to use some pieces from v1
		and e.g `prometheus.NewGauge` and some from v2 e.g. `prometheus.V2.NewDesc`
		in the same codebase.


Package-Level Constants (total 9)

	const CounterValue ValueType = 1
		Possible values for the ValueType enum. Use UntypedValue to mark a metric
		with an unknown type.

	const DefAgeBuckets = 5
		DefAgeBuckets is the default number of buckets used to calculate the
		age of observations.

	const DefBufCap = 500
		DefBufCap is the standard buffer size for collecting Summary observations.

	const DefMaxAge time.Duration = 600000000000
		DefMaxAge is the default duration for which observations stay
		relevant.

	const DefNativeHistogramZeroThreshold = 2.93874e-39
		DefNativeHistogramZeroThreshold is the default value for
		NativeHistogramZeroThreshold in the HistogramOpts.
		
		The value is 2^-128 (or 0.5*2^-127 in the actual IEEE 754 representation),
		which is a bucket boundary at all possible resolutions.

	const ExemplarMaxRunes = 128
		ExemplarMaxRunes is the max total number of runes allowed in exemplar labels.

	const GaugeValue ValueType = 2
		Possible values for the ValueType enum. Use UntypedValue to mark a metric
		with an unknown type.

	const NativeHistogramZeroThresholdZero = -1
		NativeHistogramZeroThresholdZero can be used as NativeHistogramZeroThreshold
		in the HistogramOpts to create a zero bucket of width zero, i.e. a zero
		bucket that only receives observations of precisely zero.

	const UntypedValue ValueType = 3
		Possible values for the ValueType enum. Use UntypedValue to mark a metric
		with an unknown type.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.