var GoCollectorDefaultRuntimeMetrics =regexp.MustCompile(`/gc/gogc:percent|/gc/gomemlimit:bytes|/sched/gomaxprocs:threads`)

funcAlmostEqualFloat64¶added inv1.14.0

func AlmostEqualFloat64(a, b, epsilonfloat64)bool

AlmostEqualFloat64 returns true if a and b are equal within a relative errorof epsilon. Seehttp://floating-point-gui.de/errors/comparison/ for thedetails of the applied method.

funcAlmostEqualFloat64s¶added inv1.14.0

func AlmostEqualFloat64s(a, b []float64, epsilonfloat64)bool

AlmostEqualFloat64s is the slice form of AlmostEqualFloat64.

funcGetUnifiedDiffString¶added inv1.13.0

func GetUnifiedDiffString(diffUnifiedDiff) (string,error)

Like WriteUnifiedDiff but returns the diff a string.

a := `onetwothreefourfmt.Printf("%s,%T",a,b)`b := `zeroonethreefour`diff := UnifiedDiff{A:        SplitLines(a),B:        SplitLines(b),FromFile: "Original",FromDate: "2005-01-26 23:30:50",ToFile:   "Current",ToDate:   "2010-04-02 10:20:52",Context:  3,}result, _ := GetUnifiedDiffString(diff)fmt.Println(strings.ReplaceAll(result, "\t", " "))

Output:--- Original 2005-01-26 23:30:50+++ Current 2010-04-02 10:20:52@@ -1,5 +1,4 @@+zero one-two three four-fmt.Printf("%s,%T",a,b)

funcNormalizeMetricFamilies¶

func NormalizeMetricFamilies(metricFamiliesByName map[string]*dto.MetricFamily) []*dto.MetricFamily

NormalizeMetricFamilies returns a MetricFamily slice with emptyMetricFamilies pruned and the remaining MetricFamilies sorted by name withinthe slice, with the contained Metrics sorted within each MetricFamily.

funcRuntimeMetricsBucketsForUnit¶added inv0.12.1

func RuntimeMetricsBucketsForUnit(buckets []float64, unitstring) []float64

RuntimeMetricsBucketsForUnit takes a set of buckets obtained for a runtime/metrics histogramtype (so, lower-bound inclusive) and a unit from a runtime/metrics name, and producesa reduced set of buckets. This function always removes any -Inf bucket as it's representedas the bottom-most upper-bound inclusive bucket in Prometheus.

funcRuntimeMetricsToProm¶added inv0.12.1

func RuntimeMetricsToProm(d *metrics.Description) (string,string,string,bool)

RuntimeMetricsToProm produces a Prometheus metric name from a runtime/metricsmetric description and validates whether the metric is suitable for integrationwith Prometheus.

Returns false if a name could not be produced, or if Prometheus does not understandthe runtime/metrics Kind.

Note that the main reason a name couldn't be produced is if the runtime/metricspackage exports a name with characters outside the valid Prometheus metric namecharacter set. This is theoretically possible, but should never happen in practice.Still, don't rely on it.

funcSplitLines¶added inv1.13.0

func SplitLines(sstring) []string

Split a string on "\n" while preserving them. The output can be usedas input for UnifiedDiff and ContextDiff structures.

funcWriteUnifiedDiff¶added inv1.13.0

func WriteUnifiedDiff(writerio.Writer, diffUnifiedDiff)error

Compare two sequences of lines; generate the delta as a unified diff.

Unified diffs are a compact way of showing line changes and a fewlines of context. The number of context lines is set by 'n' whichdefaults to three.

By default, the diff control lines (those with ---, +++, or @@) arecreated with a trailing newline. This is helpful so that inputscreated from file.readlines() result in diffs that are suitable forfile.writelines() since both the inputs and outputs have trailingnewlines.

For inputs that do not have trailing newlines, set the linetermargument to "" so that the output will be uniformly newline free.

The unidiff format normally has a header for filenames and modificationtimes. Any or all of these may be specified using strings for'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.The modification times are normally expressed in the ISO 8601 format.

typeGoCollectorOptions¶added inv1.13.0

type GoCollectorOptions struct {DisableMemStatsLikeMetricsboolRuntimeMetricSumForHist    map[string]stringRuntimeMetricRules         []GoCollectorRule}

GoCollectorOptions should not be used be directly by anything, except `collectors` package.Use it via collectors package instead. See issuehttps://github.com/prometheus/client_golang/issues/1030.

This is internal, so external users only can use it via `collector.WithGoCollector*` methods

typeGoCollectorRule¶added inv1.13.0

type GoCollectorRule struct {Matcher *regexp.RegexpDenybool}

typeLabelPairSorter¶added inv1.13.0

type LabelPairSorter []*dto.LabelPair

LabelPairSorter implements sort.Interface. It is used to sort a slice ofdto.LabelPair pointers.

func (sLabelPairSorter) Len()int

func (sLabelPairSorter) Less(i, jint)bool

func (sLabelPairSorter) Swap(i, jint)

typeMatch¶added inv1.13.0

type Match struct {AintBintSizeint}

typeMetricSorter¶added inv1.13.0

type MetricSorter []*dto.Metric

MetricSorter is a sortable slice of *dto.Metric.

func (sMetricSorter) Len()int

func (sMetricSorter) Less(i, jint)bool

func (sMetricSorter) Swap(i, jint)

typeOpCode¶added inv1.13.0

type OpCode struct {TagbyteI1intI2intJ1intJ2int}

typeSequenceMatcher¶added inv1.13.0

type SequenceMatcher struct {IsJunk func(string)bool// contains filtered or unexported fields}

SequenceMatcher compares sequence of strings. The basicalgorithm predates, and is a little fancier than, an algorithmpublished in the late 1980's by Ratcliff and Obershelp under thehyperbolic name "gestalt pattern matching". The basic idea is to findthe longest contiguous matching subsequence that contains no "junk"elements (R-O doesn't address junk). The same idea is then appliedrecursively to the pieces of the sequences to the left and to the rightof the matching subsequence. This does not yield minimal editsequences, but does tend to yield matches that "look right" to people.

SequenceMatcher tries to compute a "human-friendly diff" between twosequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is thelongest *contiguous* & junk-free matching subsequence. That's whatcatches peoples' eyes. The Windows(tm) windiff has another interestingnotion, pairing up elements that appear uniquely in each sequence.That, and the method here, appear to yield more intuitive differencereports than does diff. This method appears to be the least vulnerableto synching up on blocks of "junk lines", though (like blank lines inordinary text files, or maybe "<P>" lines in HTML files). That may bebecause this is the only method of the 3 that has a *concept* of"junk" <wink>.

Timing: Basic R-O is cubic time worst case and quadratic time expectedcase. SequenceMatcher is quadratic time for the worst case and hasexpected-case behavior dependent in a complicated way on how manyelements the sequences have in common; best case time is linear.

func NewMatcher(a, b []string) *SequenceMatcher

func NewMatcherWithJunk(a, b []string, autoJunkbool,isJunk func(string)bool,) *SequenceMatcher

func (m *SequenceMatcher) GetGroupedOpCodes(nint) [][]OpCode

func (m *SequenceMatcher) GetMatchingBlocks() []Match

func (m *SequenceMatcher) GetOpCodes() []OpCode

func (m *SequenceMatcher) QuickRatio()float64

func (m *SequenceMatcher) Ratio()float64

func (m *SequenceMatcher) RealQuickRatio()float64

func (m *SequenceMatcher) SetSeq1(a []string)

func (m *SequenceMatcher) SetSeq2(b []string)

func (m *SequenceMatcher) SetSeqs(a, b []string)

typeUnifiedDiff¶added inv1.13.0

type UnifiedDiff struct {A        []string// First sequence linesFromFilestring// First file nameFromDatestring// First file timeB        []string// Second sequence linesToFilestring// Second file nameToDatestring// Second file timeEolstring// Headers end of line, defaults to LFContextint// Number of context lines}

Unified diff parameters