Vendor main dependencies.
This commit is contained in:
parent
49a09ab7dd
commit
dd5e3fba01
2738 changed files with 1045689 additions and 0 deletions
22
vendor/github.com/go-kit/kit/LICENSE
generated
vendored
Normal file
22
vendor/github.com/go-kit/kit/LICENSE
generated
vendored
Normal file
|
@ -0,0 +1,22 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2015 Peter Bourgon
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
60
vendor/github.com/go-kit/kit/metrics/doc.go
generated
vendored
Normal file
60
vendor/github.com/go-kit/kit/metrics/doc.go
generated
vendored
Normal file
|
@ -0,0 +1,60 @@
|
|||
// Package metrics provides a framework for application instrumentation. All
|
||||
// metrics are safe for concurrent use. Considerable design influence has been
|
||||
// taken from https://github.com/codahale/metrics and https://prometheus.io.
|
||||
//
|
||||
// This package contains the common interfaces. Your code should take these
|
||||
// interfaces as parameters. Implementations are provided for different
|
||||
// instrumentation systems in the various subdirectories.
|
||||
//
|
||||
// Usage
|
||||
//
|
||||
// Metrics are dependencies and should be passed to the components that need
|
||||
// them in the same way you'd construct and pass a database handle, or reference
|
||||
// to another component. So, create metrics in your func main, using whichever
|
||||
// concrete implementation is appropriate for your organization.
|
||||
//
|
||||
// latency := prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
|
||||
// Namespace: "myteam",
|
||||
// Subsystem: "foosvc",
|
||||
// Name: "request_latency_seconds",
|
||||
// Help: "Incoming request latency in seconds."
|
||||
// }, []string{"method", "status_code"})
|
||||
//
|
||||
// Write your components to take the metrics they will use as parameters to
|
||||
// their constructors. Use the interface types, not the concrete types. That is,
|
||||
//
|
||||
// // NewAPI takes metrics.Histogram, not *prometheus.Summary
|
||||
// func NewAPI(s Store, logger log.Logger, latency metrics.Histogram) *API {
|
||||
// // ...
|
||||
// }
|
||||
//
|
||||
// func (a *API) ServeFoo(w http.ResponseWriter, r *http.Request) {
|
||||
// begin := time.Now()
|
||||
// // ...
|
||||
// a.latency.Observe(time.Since(begin).Seconds())
|
||||
// }
|
||||
//
|
||||
// Finally, pass the metrics as dependencies when building your object graph.
|
||||
// This should happen in func main, not in the global scope.
|
||||
//
|
||||
// api := NewAPI(store, logger, latency)
|
||||
// http.ListenAndServe("/", api)
|
||||
//
|
||||
// Implementation details
|
||||
//
|
||||
// Each telemetry system has different semantics for label values, push vs.
|
||||
// pull, support for histograms, etc. These properties influence the design of
|
||||
// their respective packages. This table attempts to summarize the key points of
|
||||
// distinction.
|
||||
//
|
||||
// SYSTEM DIM COUNTERS GAUGES HISTOGRAMS
|
||||
// dogstatsd n batch, push-aggregate batch, push-aggregate native, batch, push-each
|
||||
// statsd 1 batch, push-aggregate batch, push-aggregate native, batch, push-each
|
||||
// graphite 1 batch, push-aggregate batch, push-aggregate synthetic, batch, push-aggregate
|
||||
// expvar 1 atomic atomic synthetic, batch, in-place expose
|
||||
// influx n custom custom custom
|
||||
// prometheus n native native native
|
||||
// circonus 1 native native native
|
||||
// pcp 1 native native native
|
||||
//
|
||||
package metrics
|
14
vendor/github.com/go-kit/kit/metrics/internal/lv/labelvalues.go
generated
vendored
Normal file
14
vendor/github.com/go-kit/kit/metrics/internal/lv/labelvalues.go
generated
vendored
Normal file
|
@ -0,0 +1,14 @@
|
|||
package lv
|
||||
|
||||
// LabelValues is a type alias that provides validation on its With method.
|
||||
// Metrics may include it as a member to help them satisfy With semantics and
|
||||
// save some code duplication.
|
||||
type LabelValues []string
|
||||
|
||||
// With validates the input, and returns a new aggregate labelValues.
|
||||
func (lvs LabelValues) With(labelValues ...string) LabelValues {
|
||||
if len(labelValues)%2 != 0 {
|
||||
labelValues = append(labelValues, "unknown")
|
||||
}
|
||||
return append(lvs, labelValues...)
|
||||
}
|
106
vendor/github.com/go-kit/kit/metrics/internal/lv/space.go
generated
vendored
Normal file
106
vendor/github.com/go-kit/kit/metrics/internal/lv/space.go
generated
vendored
Normal file
|
@ -0,0 +1,106 @@
|
|||
package lv
|
||||
|
||||
import "sync"
|
||||
|
||||
// NewSpace returns an N-dimensional vector space.
|
||||
func NewSpace() *Space {
|
||||
return &Space{}
|
||||
}
|
||||
|
||||
// Space represents an N-dimensional vector space. Each name and unique label
|
||||
// value pair establishes a new dimension and point within that dimension. Order
|
||||
// matters, i.e. [a=1 b=2] identifies a different timeseries than [b=2 a=1].
|
||||
type Space struct {
|
||||
mtx sync.RWMutex
|
||||
nodes map[string]*node
|
||||
}
|
||||
|
||||
// Observe locates the time series identified by the name and label values in
|
||||
// the vector space, and appends the value to the list of observations.
|
||||
func (s *Space) Observe(name string, lvs LabelValues, value float64) {
|
||||
s.nodeFor(name).observe(lvs, value)
|
||||
}
|
||||
|
||||
// Walk traverses the vector space and invokes fn for each non-empty time series
|
||||
// which is encountered. Return false to abort the traversal.
|
||||
func (s *Space) Walk(fn func(name string, lvs LabelValues, observations []float64) bool) {
|
||||
s.mtx.RLock()
|
||||
defer s.mtx.RUnlock()
|
||||
for name, node := range s.nodes {
|
||||
f := func(lvs LabelValues, observations []float64) bool { return fn(name, lvs, observations) }
|
||||
if !node.walk(LabelValues{}, f) {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reset empties the current space and returns a new Space with the old
|
||||
// contents. Reset a Space to get an immutable copy suitable for walking.
|
||||
func (s *Space) Reset() *Space {
|
||||
s.mtx.Lock()
|
||||
defer s.mtx.Unlock()
|
||||
n := NewSpace()
|
||||
n.nodes, s.nodes = s.nodes, n.nodes
|
||||
return n
|
||||
}
|
||||
|
||||
func (s *Space) nodeFor(name string) *node {
|
||||
s.mtx.Lock()
|
||||
defer s.mtx.Unlock()
|
||||
if s.nodes == nil {
|
||||
s.nodes = map[string]*node{}
|
||||
}
|
||||
n, ok := s.nodes[name]
|
||||
if !ok {
|
||||
n = &node{}
|
||||
s.nodes[name] = n
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// node exists at a specific point in the N-dimensional vector space of all
|
||||
// possible label values. The node collects observations and has child nodes
|
||||
// with greater specificity.
|
||||
type node struct {
|
||||
mtx sync.RWMutex
|
||||
observations []float64
|
||||
children map[pair]*node
|
||||
}
|
||||
|
||||
type pair struct{ label, value string }
|
||||
|
||||
func (n *node) observe(lvs LabelValues, value float64) {
|
||||
n.mtx.Lock()
|
||||
defer n.mtx.Unlock()
|
||||
if len(lvs) == 0 {
|
||||
n.observations = append(n.observations, value)
|
||||
return
|
||||
}
|
||||
if len(lvs) < 2 {
|
||||
panic("too few LabelValues; programmer error!")
|
||||
}
|
||||
head, tail := pair{lvs[0], lvs[1]}, lvs[2:]
|
||||
if n.children == nil {
|
||||
n.children = map[pair]*node{}
|
||||
}
|
||||
child, ok := n.children[head]
|
||||
if !ok {
|
||||
child = &node{}
|
||||
n.children[head] = child
|
||||
}
|
||||
child.observe(tail, value)
|
||||
}
|
||||
|
||||
func (n *node) walk(lvs LabelValues, fn func(LabelValues, []float64) bool) bool {
|
||||
n.mtx.RLock()
|
||||
defer n.mtx.RUnlock()
|
||||
if len(n.observations) > 0 && !fn(lvs, n.observations) {
|
||||
return false
|
||||
}
|
||||
for p, child := range n.children {
|
||||
if !child.walk(append(lvs, p.label, p.value), fn) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
24
vendor/github.com/go-kit/kit/metrics/metrics.go
generated
vendored
Normal file
24
vendor/github.com/go-kit/kit/metrics/metrics.go
generated
vendored
Normal file
|
@ -0,0 +1,24 @@
|
|||
package metrics
|
||||
|
||||
// Counter describes a metric that accumulates values monotonically.
|
||||
// An example of a counter is the number of received HTTP requests.
|
||||
type Counter interface {
|
||||
With(labelValues ...string) Counter
|
||||
Add(delta float64)
|
||||
}
|
||||
|
||||
// Gauge describes a metric that takes specific values over time.
|
||||
// An example of a gauge is the current depth of a job queue.
|
||||
type Gauge interface {
|
||||
With(labelValues ...string) Gauge
|
||||
Set(value float64)
|
||||
}
|
||||
|
||||
// Histogram describes a metric that takes repeated observations of the same
|
||||
// kind of thing, and produces a statistical summary of those observations,
|
||||
// typically expressed as quantiles or buckets. An example of a histogram is
|
||||
// HTTP request latencies.
|
||||
type Histogram interface {
|
||||
With(labelValues ...string) Histogram
|
||||
Observe(value float64)
|
||||
}
|
165
vendor/github.com/go-kit/kit/metrics/prometheus/prometheus.go
generated
vendored
Normal file
165
vendor/github.com/go-kit/kit/metrics/prometheus/prometheus.go
generated
vendored
Normal file
|
@ -0,0 +1,165 @@
|
|||
// Package prometheus provides Prometheus implementations for metrics.
|
||||
// Individual metrics are mapped to their Prometheus counterparts, and
|
||||
// (depending on the constructor used) may be automatically registered in the
|
||||
// global Prometheus metrics registry.
|
||||
package prometheus
|
||||
|
||||
import (
|
||||
"github.com/prometheus/client_golang/prometheus"
|
||||
|
||||
"github.com/go-kit/kit/metrics"
|
||||
"github.com/go-kit/kit/metrics/internal/lv"
|
||||
)
|
||||
|
||||
// Counter implements Counter, via a Prometheus CounterVec.
|
||||
type Counter struct {
|
||||
cv *prometheus.CounterVec
|
||||
lvs lv.LabelValues
|
||||
}
|
||||
|
||||
// NewCounterFrom constructs and registers a Prometheus CounterVec,
|
||||
// and returns a usable Counter object.
|
||||
func NewCounterFrom(opts prometheus.CounterOpts, labelNames []string) *Counter {
|
||||
cv := prometheus.NewCounterVec(opts, labelNames)
|
||||
prometheus.MustRegister(cv)
|
||||
return NewCounter(cv)
|
||||
}
|
||||
|
||||
// NewCounter wraps the CounterVec and returns a usable Counter object.
|
||||
func NewCounter(cv *prometheus.CounterVec) *Counter {
|
||||
return &Counter{
|
||||
cv: cv,
|
||||
}
|
||||
}
|
||||
|
||||
// With implements Counter.
|
||||
func (c *Counter) With(labelValues ...string) metrics.Counter {
|
||||
return &Counter{
|
||||
cv: c.cv,
|
||||
lvs: c.lvs.With(labelValues...),
|
||||
}
|
||||
}
|
||||
|
||||
// Add implements Counter.
|
||||
func (c *Counter) Add(delta float64) {
|
||||
c.cv.With(makeLabels(c.lvs...)).Add(delta)
|
||||
}
|
||||
|
||||
// Gauge implements Gauge, via a Prometheus GaugeVec.
|
||||
type Gauge struct {
|
||||
gv *prometheus.GaugeVec
|
||||
lvs lv.LabelValues
|
||||
}
|
||||
|
||||
// NewGaugeFrom construts and registers a Prometheus GaugeVec,
|
||||
// and returns a usable Gauge object.
|
||||
func NewGaugeFrom(opts prometheus.GaugeOpts, labelNames []string) *Gauge {
|
||||
gv := prometheus.NewGaugeVec(opts, labelNames)
|
||||
prometheus.MustRegister(gv)
|
||||
return NewGauge(gv)
|
||||
}
|
||||
|
||||
// NewGauge wraps the GaugeVec and returns a usable Gauge object.
|
||||
func NewGauge(gv *prometheus.GaugeVec) *Gauge {
|
||||
return &Gauge{
|
||||
gv: gv,
|
||||
}
|
||||
}
|
||||
|
||||
// With implements Gauge.
|
||||
func (g *Gauge) With(labelValues ...string) metrics.Gauge {
|
||||
return &Gauge{
|
||||
gv: g.gv,
|
||||
lvs: g.lvs.With(labelValues...),
|
||||
}
|
||||
}
|
||||
|
||||
// Set implements Gauge.
|
||||
func (g *Gauge) Set(value float64) {
|
||||
g.gv.With(makeLabels(g.lvs...)).Set(value)
|
||||
}
|
||||
|
||||
// Add is supported by Prometheus GaugeVecs.
|
||||
func (g *Gauge) Add(delta float64) {
|
||||
g.gv.With(makeLabels(g.lvs...)).Add(delta)
|
||||
}
|
||||
|
||||
// Summary implements Histogram, via a Prometheus SummaryVec. The difference
|
||||
// between a Summary and a Histogram is that Summaries don't require predefined
|
||||
// quantile buckets, but cannot be statistically aggregated.
|
||||
type Summary struct {
|
||||
sv *prometheus.SummaryVec
|
||||
lvs lv.LabelValues
|
||||
}
|
||||
|
||||
// NewSummaryFrom constructs and registers a Prometheus SummaryVec,
|
||||
// and returns a usable Summary object.
|
||||
func NewSummaryFrom(opts prometheus.SummaryOpts, labelNames []string) *Summary {
|
||||
sv := prometheus.NewSummaryVec(opts, labelNames)
|
||||
prometheus.MustRegister(sv)
|
||||
return NewSummary(sv)
|
||||
}
|
||||
|
||||
// NewSummary wraps the SummaryVec and returns a usable Summary object.
|
||||
func NewSummary(sv *prometheus.SummaryVec) *Summary {
|
||||
return &Summary{
|
||||
sv: sv,
|
||||
}
|
||||
}
|
||||
|
||||
// With implements Histogram.
|
||||
func (s *Summary) With(labelValues ...string) metrics.Histogram {
|
||||
return &Summary{
|
||||
sv: s.sv,
|
||||
lvs: s.lvs.With(labelValues...),
|
||||
}
|
||||
}
|
||||
|
||||
// Observe implements Histogram.
|
||||
func (s *Summary) Observe(value float64) {
|
||||
s.sv.With(makeLabels(s.lvs...)).Observe(value)
|
||||
}
|
||||
|
||||
// Histogram implements Histogram via a Prometheus HistogramVec. The difference
|
||||
// between a Histogram and a Summary is that Histograms require predefined
|
||||
// quantile buckets, and can be statistically aggregated.
|
||||
type Histogram struct {
|
||||
hv *prometheus.HistogramVec
|
||||
lvs lv.LabelValues
|
||||
}
|
||||
|
||||
// NewHistogramFrom constructs and registers a Prometheus HistogramVec,
|
||||
// and returns a usable Histogram object.
|
||||
func NewHistogramFrom(opts prometheus.HistogramOpts, labelNames []string) *Histogram {
|
||||
hv := prometheus.NewHistogramVec(opts, labelNames)
|
||||
prometheus.MustRegister(hv)
|
||||
return NewHistogram(hv)
|
||||
}
|
||||
|
||||
// NewHistogram wraps the HistogramVec and returns a usable Histogram object.
|
||||
func NewHistogram(hv *prometheus.HistogramVec) *Histogram {
|
||||
return &Histogram{
|
||||
hv: hv,
|
||||
}
|
||||
}
|
||||
|
||||
// With implements Histogram.
|
||||
func (h *Histogram) With(labelValues ...string) metrics.Histogram {
|
||||
return &Histogram{
|
||||
hv: h.hv,
|
||||
lvs: h.lvs.With(labelValues...),
|
||||
}
|
||||
}
|
||||
|
||||
// Observe implements Histogram.
|
||||
func (h *Histogram) Observe(value float64) {
|
||||
h.hv.With(makeLabels(h.lvs...)).Observe(value)
|
||||
}
|
||||
|
||||
func makeLabels(labelValues ...string) prometheus.Labels {
|
||||
labels := prometheus.Labels{}
|
||||
for i := 0; i < len(labelValues); i += 2 {
|
||||
labels[labelValues[i]] = labelValues[i+1]
|
||||
}
|
||||
return labels
|
||||
}
|
28
vendor/github.com/go-kit/kit/metrics/timer.go
generated
vendored
Normal file
28
vendor/github.com/go-kit/kit/metrics/timer.go
generated
vendored
Normal file
|
@ -0,0 +1,28 @@
|
|||
package metrics
|
||||
|
||||
import "time"
|
||||
|
||||
// Timer acts as a stopwatch, sending observations to a wrapped histogram.
|
||||
// It's a bit of helpful syntax sugar for h.Observe(time.Since(x)).
|
||||
type Timer struct {
|
||||
h Histogram
|
||||
t time.Time
|
||||
}
|
||||
|
||||
// NewTimer wraps the given histogram and records the current time.
|
||||
func NewTimer(h Histogram) *Timer {
|
||||
return &Timer{
|
||||
h: h,
|
||||
t: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
// ObserveDuration captures the number of seconds since the timer was
|
||||
// constructed, and forwards that observation to the histogram.
|
||||
func (t *Timer) ObserveDuration() {
|
||||
d := time.Since(t.t).Seconds()
|
||||
if d < 0 {
|
||||
d = 0
|
||||
}
|
||||
t.h.Observe(d)
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue