// ToFloat64 collects all Metrics from the provided Collector. It expects that // this results in exactly one Metric being collected, which must be a Gauge, // Counter, or Untyped. In all other cases, ToFloat64 panics. ToFloat64 returns // the value of the collected Metric. // // The Collector provided is typically a simple instance of Gauge or Counter, or // – less commonly – a GaugeVec or CounterVec with exactly one element. But any // Collector fulfilling the prerequisites described above will do. // // Use this function with caution. It is computationally very expensive and thus // not suited at all to read values from Metrics in regular code. This is really // only for testing purposes, and even for testing, other approaches are often // more appropriate (see this package's documentation). // // A clear anti-pattern would be to use a metric type from the prometheus // package to track values that are also needed for something else than the // exposition of Prometheus metrics. For example, you would like to track the // number of items in a queue because your code should reject queuing further // items if a certain limit is reached. It is tempting to track the number of // items in a prometheus.Gauge, as it is then easily available as a metric for // exposition, too. However, then you would need to call ToFloat64 in your // regular code, potentially quite often. The recommended way is to track the // number of items conventionally (in the way you would have done it without // considering Prometheus metrics) and then expose the number with a // prometheus.GaugeFunc. func ToFloat64(c prometheus.Collector) float64 { … } // CollectAndCount registers the provided Collector with a newly created // pedantic Registry. It then calls GatherAndCount with that Registry and with // the provided metricNames. In the unlikely case that the registration or the // gathering fails, this function panics. (This is inconsistent with the other // CollectAnd… functions in this package and has historical reasons. Changing // the function signature would be a breaking change and will therefore only // happen with the next major version bump.) func CollectAndCount(c prometheus.Collector, metricNames ...string) int { … } // GatherAndCount gathers all metrics from the provided Gatherer and counts // them. It returns the number of metric children in all gathered metric // families together. If any metricNames are provided, only metrics with those // names are counted. func GatherAndCount(g prometheus.Gatherer, metricNames ...string) (int, error) { … } // ScrapeAndCompare calls a remote exporter's endpoint which is expected to return some metrics in // plain text format. Then it compares it with the results that the `expected` would return. // If the `metricNames` is not empty it would filter the comparison only to the given metric names. func ScrapeAndCompare(url string, expected io.Reader, metricNames ...string) error { … } // CollectAndCompare registers the provided Collector with a newly created // pedantic Registry. It then calls GatherAndCompare with that Registry and with // the provided metricNames. func CollectAndCompare(c prometheus.Collector, expected io.Reader, metricNames ...string) error { … } // GatherAndCompare gathers all metrics from the provided Gatherer and compares // it to an expected output read from the provided Reader in the Prometheus text // exposition format. If any metricNames are provided, only metrics with those // names are compared. func GatherAndCompare(g prometheus.Gatherer, expected io.Reader, metricNames ...string) error { … } // TransactionalGatherAndCompare gathers all metrics from the provided Gatherer and compares // it to an expected output read from the provided Reader in the Prometheus text // exposition format. If any metricNames are provided, only metrics with those // names are compared. func TransactionalGatherAndCompare(g prometheus.TransactionalGatherer, expected io.Reader, metricNames ...string) error { … } // convertReaderToMetricFamily would read from a io.Reader object and convert it to a slice of // dto.MetricFamily. func convertReaderToMetricFamily(reader io.Reader) ([]*dto.MetricFamily, error) { … } // compareMetricFamilies would compare 2 slices of metric families, and optionally filters both of // them to the `metricNames` provided. func compareMetricFamilies(got, expected []*dto.MetricFamily, metricNames ...string) error { … } // compare encodes both provided slices of metric families into the text format, // compares their string message, and returns an error if they do not match. // The error contains the encoded text of both the desired and the actual // result. func compare(got, want []*dto.MetricFamily) error { … } // diff returns a diff of both values as long as both are of the same type and // are a struct, map, slice, array or string. Otherwise it returns an empty string. func diff(expected, actual interface{ … } // typeAndKind returns the type and kind of the given interface{} func typeAndKind(v interface{ … } func filterMetrics(metrics []*dto.MetricFamily, names []string) []*dto.MetricFamily { … }