diff --git a/.golangci.yml b/.golangci.yml index aabcb0ddb..5875fccc6 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -77,3 +77,12 @@ issues: - path: cmd/controller-manager/controller-manager.go linters: - gci + - path: cmd/descheduler/main.go + linters: + - gci + - path: cmd/scheduler/main.go + linters: + - gci + - path: cmd/scheduler-estimator/main.go + linters: + - gci diff --git a/cmd/agent/main.go b/cmd/agent/main.go index 2bfc28019..9089a5609 100644 --- a/cmd/agent/main.go +++ b/cmd/agent/main.go @@ -5,11 +5,11 @@ import ( // Note that Kubernetes registers workqueue metrics to default prometheus Registry. And the registry will be // initialized by the package 'k8s.io/apiserver/pkg/server'. - // See https://github.com/kubernetes/kubernetes/blob/f61ed439882e34d9dad28b602afdc852feb2337a/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25 + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25-L26 // But the controller-runtime registers workqueue metrics to its own Registry instead of default prometheus Registry. - // See https://github.com/kubernetes-sigs/controller-runtime/blob/4d10a0615b11507451ecb58bfd59f0f6ef313a29/pkg/metrics/workqueue.go#L24-L26 + // See https://github.com/kubernetes-sigs/controller-runtime/blob/release-0.14/pkg/metrics/workqueue.go#L24-L26 // However, global workqueue metrics factory will be only initialized once. - // See https://github.com/kubernetes/kubernetes/blob/f61ed439882e34d9dad28b602afdc852feb2337a/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 // So this package should be initialized before 'k8s.io/apiserver/pkg/server', thus the internal registry of // controller-runtime could be set first. _ "sigs.k8s.io/controller-runtime/pkg/metrics" diff --git a/cmd/controller-manager/controller-manager.go b/cmd/controller-manager/controller-manager.go index 1a23e1c43..83dc0e46a 100644 --- a/cmd/controller-manager/controller-manager.go +++ b/cmd/controller-manager/controller-manager.go @@ -5,11 +5,11 @@ import ( // Note that Kubernetes registers workqueue metrics to default prometheus Registry. And the registry will be // initialized by the package 'k8s.io/apiserver/pkg/server'. - // See https://github.com/kubernetes/kubernetes/blob/f61ed439882e34d9dad28b602afdc852feb2337a/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25 + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25-L26 // But the controller-runtime registers workqueue metrics to its own Registry instead of default prometheus Registry. - // See https://github.com/kubernetes-sigs/controller-runtime/blob/4d10a0615b11507451ecb58bfd59f0f6ef313a29/pkg/metrics/workqueue.go#L24-L26 + // See https://github.com/kubernetes-sigs/controller-runtime/blob/release-0.14/pkg/metrics/workqueue.go#L24-L26 // However, global workqueue metrics factory will be only initialized once. - // See https://github.com/kubernetes/kubernetes/blob/f61ed439882e34d9dad28b602afdc852feb2337a/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 // So this package should be initialized before 'k8s.io/apiserver/pkg/server', thus the internal registry of // controller-runtime could be set first. _ "sigs.k8s.io/controller-runtime/pkg/metrics" diff --git a/cmd/descheduler/app/descheduler.go b/cmd/descheduler/app/descheduler.go index 62435dbf5..d4525a45a 100644 --- a/cmd/descheduler/app/descheduler.go +++ b/cmd/descheduler/app/descheduler.go @@ -20,6 +20,7 @@ import ( cliflag "k8s.io/component-base/cli/flag" "k8s.io/component-base/term" "k8s.io/klog/v2" + ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" "github.com/karmada-io/karmada/cmd/descheduler/app/options" "github.com/karmada-io/karmada/pkg/descheduler" @@ -165,7 +166,10 @@ func serveHealthzAndMetrics(address string) { _, _ = w.Write([]byte("ok")) }) - mux.Handle("/metrics", promhttp.Handler()) + mux.Handle("/metrics", promhttp.HandlerFor(ctrlmetrics.Registry, promhttp.HandlerOpts{ + ErrorHandling: promhttp.HTTPErrorOnError, + })) + httpServer := http.Server{ Addr: address, Handler: mux, diff --git a/cmd/descheduler/main.go b/cmd/descheduler/main.go index d823ee8c4..a354a7e1a 100644 --- a/cmd/descheduler/main.go +++ b/cmd/descheduler/main.go @@ -3,6 +3,17 @@ package main import ( "os" + // Note that Kubernetes registers workqueue metrics to default prometheus Registry. And the registry will be + // initialized by the package 'k8s.io/apiserver/pkg/server'. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25-L26 + // But the controller-runtime registers workqueue metrics to its own Registry instead of default prometheus Registry. + // See https://github.com/kubernetes-sigs/controller-runtime/blob/release-0.14/pkg/metrics/workqueue.go#L24-L26 + // However, global workqueue metrics factory will be only initialized once. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 + // So this package should be initialized before 'k8s.io/apiserver/pkg/server', thus the internal registry of + // controller-runtime could be set first. + _ "sigs.k8s.io/controller-runtime/pkg/metrics" + apiserver "k8s.io/apiserver/pkg/server" "k8s.io/component-base/cli" _ "k8s.io/component-base/logs/json/register" // for JSON log format registration diff --git a/cmd/scheduler-estimator/app/scheduler-estimator.go b/cmd/scheduler-estimator/app/scheduler-estimator.go index 81c217a35..5e91a7058 100644 --- a/cmd/scheduler-estimator/app/scheduler-estimator.go +++ b/cmd/scheduler-estimator/app/scheduler-estimator.go @@ -18,6 +18,7 @@ import ( cliflag "k8s.io/component-base/cli/flag" "k8s.io/component-base/term" "k8s.io/klog/v2" + ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" "github.com/karmada-io/karmada/cmd/scheduler-estimator/app/options" "github.com/karmada-io/karmada/pkg/estimator/server" @@ -112,7 +113,9 @@ func serveHealthzAndMetrics(address string) { _, _ = w.Write([]byte("ok")) }) - mux.Handle("/metrics", promhttp.Handler()) + mux.Handle("/metrics", promhttp.HandlerFor(ctrlmetrics.Registry, promhttp.HandlerOpts{ + ErrorHandling: promhttp.HTTPErrorOnError, + })) httpServer := http.Server{ Addr: address, diff --git a/cmd/scheduler-estimator/main.go b/cmd/scheduler-estimator/main.go index 1d66905b1..4b5b3a3e8 100644 --- a/cmd/scheduler-estimator/main.go +++ b/cmd/scheduler-estimator/main.go @@ -3,6 +3,17 @@ package main import ( "os" + // Note that Kubernetes registers workqueue metrics to default prometheus Registry. And the registry will be + // initialized by the package 'k8s.io/apiserver/pkg/server'. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25-L26 + // But the controller-runtime registers workqueue metrics to its own Registry instead of default prometheus Registry. + // See https://github.com/kubernetes-sigs/controller-runtime/blob/release-0.14/pkg/metrics/workqueue.go#L24-L26 + // However, global workqueue metrics factory will be only initialized once. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 + // So this package should be initialized before 'k8s.io/apiserver/pkg/server', thus the internal registry of + // controller-runtime could be set first. + _ "sigs.k8s.io/controller-runtime/pkg/metrics" + apiserver "k8s.io/apiserver/pkg/server" "k8s.io/component-base/cli" _ "k8s.io/component-base/logs/json/register" // for JSON log format registration diff --git a/cmd/scheduler/app/scheduler.go b/cmd/scheduler/app/scheduler.go index c6ea5023b..0277ad230 100644 --- a/cmd/scheduler/app/scheduler.go +++ b/cmd/scheduler/app/scheduler.go @@ -21,6 +21,7 @@ import ( cliflag "k8s.io/component-base/cli/flag" "k8s.io/component-base/term" "k8s.io/klog/v2" + ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" "github.com/karmada-io/karmada/cmd/scheduler/app/options" karmadaclientset "github.com/karmada-io/karmada/pkg/generated/clientset/versioned" @@ -197,7 +198,10 @@ func serveHealthzAndMetrics(address string) { _, _ = w.Write([]byte("ok")) }) - mux.Handle("/metrics", promhttp.Handler()) + mux.Handle("/metrics", promhttp.HandlerFor(ctrlmetrics.Registry, promhttp.HandlerOpts{ + ErrorHandling: promhttp.HTTPErrorOnError, + })) + httpServer := http.Server{ Addr: address, Handler: mux, diff --git a/cmd/scheduler/main.go b/cmd/scheduler/main.go index d1e883090..73d163312 100644 --- a/cmd/scheduler/main.go +++ b/cmd/scheduler/main.go @@ -3,6 +3,17 @@ package main import ( "os" + // Note that Kubernetes registers workqueue metrics to default prometheus Registry. And the registry will be + // initialized by the package 'k8s.io/apiserver/pkg/server'. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/component-base/metrics/prometheus/workqueue/metrics.go#L25-L26 + // But the controller-runtime registers workqueue metrics to its own Registry instead of default prometheus Registry. + // See https://github.com/kubernetes-sigs/controller-runtime/blob/release-0.14/pkg/metrics/workqueue.go#L24-L26 + // However, global workqueue metrics factory will be only initialized once. + // See https://github.com/kubernetes/kubernetes/blob/release-1.26/staging/src/k8s.io/client-go/util/workqueue/metrics.go#L257-L261 + // So this package should be initialized before 'k8s.io/apiserver/pkg/server', thus the internal registry of + // controller-runtime could be set first. + _ "sigs.k8s.io/controller-runtime/pkg/metrics" + apiserver "k8s.io/apiserver/pkg/server" "k8s.io/component-base/cli" _ "k8s.io/component-base/logs/json/register" // for JSON log format registration diff --git a/pkg/estimator/server/metrics/metrics.go b/pkg/estimator/server/metrics/metrics.go index f1cb80153..efd82ba2e 100644 --- a/pkg/estimator/server/metrics/metrics.go +++ b/pkg/estimator/server/metrics/metrics.go @@ -4,7 +4,7 @@ import ( "time" "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/client_golang/prometheus/promauto" // auto-registry collectors in default registry + ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" utilmetrics "github.com/karmada-io/karmada/pkg/util/metrics" ) @@ -33,22 +33,33 @@ const ( ) var ( - requestCount = promauto.NewCounterVec( + requestCount = prometheus.NewCounterVec( prometheus.CounterOpts{ Subsystem: SchedulerEstimatorSubsystem, Name: "estimating_request_total", Help: "Number of scheduler estimator requests", }, []string{"result", "type"}) - estimatingAlgorithmLatency = promauto.NewHistogramVec( + estimatingAlgorithmLatency = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Subsystem: SchedulerEstimatorSubsystem, Name: "estimating_algorithm_duration_seconds", Help: "Estimating algorithm latency in seconds for each step", Buckets: prometheus.ExponentialBuckets(0.001, 2, 10), }, []string{"result", "type", "step"}) + + metrics = []prometheus.Collector{ + requestCount, + estimatingAlgorithmLatency, + } ) +func init() { + for _, m := range metrics { + ctrlmetrics.Registry.MustRegister(m) + } +} + // CountRequests total number of scheduler estimator requests func CountRequests(err error, estimatingType string) { requestCount.WithLabelValues(utilmetrics.GetResultByError(err), estimatingType).Inc() diff --git a/pkg/scheduler/metrics/metrics.go b/pkg/scheduler/metrics/metrics.go index 8facdd5d7..0636ddf86 100644 --- a/pkg/scheduler/metrics/metrics.go +++ b/pkg/scheduler/metrics/metrics.go @@ -4,7 +4,7 @@ import ( "time" "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/client_golang/prometheus/promauto" + ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" utilmetrics "github.com/karmada-io/karmada/pkg/util/metrics" ) @@ -42,14 +42,14 @@ const ( ) var ( - scheduleAttempts = promauto.NewCounterVec( + scheduleAttempts = prometheus.NewCounterVec( prometheus.CounterOpts{ Subsystem: SchedulerSubsystem, Name: "schedule_attempts_total", Help: "Number of attempts to schedule resourceBinding", }, []string{"result", "schedule_type"}) - e2eSchedulingLatency = promauto.NewHistogramVec( + e2eSchedulingLatency = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Subsystem: SchedulerSubsystem, Name: "e2e_scheduling_duration_seconds", @@ -57,7 +57,7 @@ var ( Buckets: prometheus.ExponentialBuckets(0.001, 2, 15), }, []string{"result", "schedule_type"}) - schedulingAlgorithmLatency = promauto.NewHistogramVec( + schedulingAlgorithmLatency = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Subsystem: SchedulerSubsystem, Name: "scheduling_algorithm_duration_seconds", @@ -66,7 +66,7 @@ var ( }, []string{"schedule_step"}) // SchedulerQueueIncomingBindings is the number of bindings added to scheduling queues by event type. - SchedulerQueueIncomingBindings = promauto.NewCounterVec( + SchedulerQueueIncomingBindings = prometheus.NewCounterVec( prometheus.CounterOpts{ Subsystem: SchedulerSubsystem, Name: "queue_incoming_bindings_total", @@ -74,7 +74,7 @@ var ( }, []string{"event"}) // FrameworkExtensionPointDuration is the metrics which indicates the latency for running all plugins of a specific extension point. - FrameworkExtensionPointDuration = promauto.NewHistogramVec( + FrameworkExtensionPointDuration = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Subsystem: SchedulerSubsystem, Name: "framework_extension_point_duration_seconds", @@ -85,7 +85,7 @@ var ( []string{"extension_point", "result"}) // PluginExecutionDuration is the metrics which indicates the duration for running a plugin at a specific extension point. - PluginExecutionDuration = promauto.NewHistogramVec( + PluginExecutionDuration = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Subsystem: SchedulerSubsystem, Name: "plugin_execution_duration_seconds", @@ -95,8 +95,23 @@ var ( Buckets: prometheus.ExponentialBuckets(0.00001, 1.5, 20), }, []string{"plugin", "extension_point", "result"}) + + metrics = []prometheus.Collector{ + scheduleAttempts, + e2eSchedulingLatency, + schedulingAlgorithmLatency, + SchedulerQueueIncomingBindings, + FrameworkExtensionPointDuration, + PluginExecutionDuration, + } ) +func init() { + for _, m := range metrics { + ctrlmetrics.Registry.MustRegister(m) + } +} + // BindingSchedule can record a scheduling attempt and the duration // since `start`. func BindingSchedule(scheduleType string, duration float64, err error) { diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go index 37c673f9b..0acf88258 100644 --- a/pkg/scheduler/scheduler.go +++ b/pkg/scheduler/scheduler.go @@ -175,7 +175,7 @@ func NewScheduler(dynamicClient dynamic.Interface, karmadaClient karmadaclientse clusterBindingLister := factory.Work().V1alpha2().ClusterResourceBindings().Lister() clusterPolicyLister := factory.Policy().V1alpha1().ClusterPropagationPolicies().Lister() clusterLister := factory.Cluster().V1alpha1().Clusters().Lister() - queue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()) + queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "scheduler-queue") schedulerCache := schedulercache.NewCache(clusterLister) options := schedulerOptions{} diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promauto/auto.go b/vendor/github.com/prometheus/client_golang/prometheus/promauto/auto.go deleted file mode 100644 index f8d50d1f9..000000000 --- a/vendor/github.com/prometheus/client_golang/prometheus/promauto/auto.go +++ /dev/null @@ -1,376 +0,0 @@ -// Copyright 2018 The Prometheus Authors -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package promauto provides alternative constructors for the fundamental -// Prometheus metric types and their …Vec and …Func variants. The difference to -// their counterparts in the prometheus package is that the promauto -// constructors return Collectors that are already registered with a -// registry. There are two sets of constructors. The constructors in the first -// set are top-level functions, while the constructors in the other set are -// methods of the Factory type. The top-level function return Collectors -// registered with the global registry (prometheus.DefaultRegisterer), while the -// methods return Collectors registered with the registry the Factory was -// constructed with. All constructors panic if the registration fails. -// -// The following example is a complete program to create a histogram of normally -// distributed random numbers from the math/rand package: -// -// package main -// -// import ( -// "math/rand" -// "net/http" -// -// "github.com/prometheus/client_golang/prometheus" -// "github.com/prometheus/client_golang/prometheus/promauto" -// "github.com/prometheus/client_golang/prometheus/promhttp" -// ) -// -// var histogram = promauto.NewHistogram(prometheus.HistogramOpts{ -// Name: "random_numbers", -// Help: "A histogram of normally distributed random numbers.", -// Buckets: prometheus.LinearBuckets(-3, .1, 61), -// }) -// -// func Random() { -// for { -// histogram.Observe(rand.NormFloat64()) -// } -// } -// -// func main() { -// go Random() -// http.Handle("/metrics", promhttp.Handler()) -// http.ListenAndServe(":1971", nil) -// } -// -// Prometheus's version of a minimal hello-world program: -// -// package main -// -// import ( -// "fmt" -// "net/http" -// -// "github.com/prometheus/client_golang/prometheus" -// "github.com/prometheus/client_golang/prometheus/promauto" -// "github.com/prometheus/client_golang/prometheus/promhttp" -// ) -// -// func main() { -// http.Handle("/", promhttp.InstrumentHandlerCounter( -// promauto.NewCounterVec( -// prometheus.CounterOpts{ -// Name: "hello_requests_total", -// Help: "Total number of hello-world requests by HTTP code.", -// }, -// []string{"code"}, -// ), -// http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { -// fmt.Fprint(w, "Hello, world!") -// }), -// )) -// http.Handle("/metrics", promhttp.Handler()) -// http.ListenAndServe(":1971", nil) -// } -// -// A Factory is created with the With(prometheus.Registerer) function, which -// enables two usage pattern. With(prometheus.Registerer) can be called once per -// line: -// -// var ( -// reg = prometheus.NewRegistry() -// randomNumbers = promauto.With(reg).NewHistogram(prometheus.HistogramOpts{ -// Name: "random_numbers", -// Help: "A histogram of normally distributed random numbers.", -// Buckets: prometheus.LinearBuckets(-3, .1, 61), -// }) -// requestCount = promauto.With(reg).NewCounterVec( -// prometheus.CounterOpts{ -// Name: "http_requests_total", -// Help: "Total number of HTTP requests by status code and method.", -// }, -// []string{"code", "method"}, -// ) -// ) -// -// Or it can be used to create a Factory once to be used multiple times: -// -// var ( -// reg = prometheus.NewRegistry() -// factory = promauto.With(reg) -// randomNumbers = factory.NewHistogram(prometheus.HistogramOpts{ -// Name: "random_numbers", -// Help: "A histogram of normally distributed random numbers.", -// Buckets: prometheus.LinearBuckets(-3, .1, 61), -// }) -// requestCount = factory.NewCounterVec( -// prometheus.CounterOpts{ -// Name: "http_requests_total", -// Help: "Total number of HTTP requests by status code and method.", -// }, -// []string{"code", "method"}, -// ) -// ) -// -// This appears very handy. So why are these constructors locked away in a -// separate package? -// -// The main problem is that registration may fail, e.g. if a metric inconsistent -// with or equal to the newly to be registered one is already registered. -// Therefore, the Register method in the prometheus.Registerer interface returns -// an error, and the same is the case for the top-level prometheus.Register -// function that registers with the global registry. The prometheus package also -// provides MustRegister versions for both. They panic if the registration -// fails, and they clearly call this out by using the Must… idiom. Panicking is -// problematic in this case because it doesn't just happen on input provided by -// the caller that is invalid on its own. Things are a bit more subtle here: -// Metric creation and registration tend to be spread widely over the -// codebase. It can easily happen that an incompatible metric is added to an -// unrelated part of the code, and suddenly code that used to work perfectly -// fine starts to panic (provided that the registration of the newly added -// metric happens before the registration of the previously existing -// metric). This may come as an even bigger surprise with the global registry, -// where simply importing another package can trigger a panic (if the newly -// imported package registers metrics in its init function). At least, in the -// prometheus package, creation of metrics and other collectors is separate from -// registration. You first create the metric, and then you decide explicitly if -// you want to register it with a local or the global registry, and if you want -// to handle the error or risk a panic. With the constructors in the promauto -// package, registration is automatic, and if it fails, it will always -// panic. Furthermore, the constructors will often be called in the var section -// of a file, which means that panicking will happen as a side effect of merely -// importing a package. -// -// A separate package allows conservative users to entirely ignore it. And -// whoever wants to use it, will do so explicitly, with an opportunity to read -// this warning. -// -// Enjoy promauto responsibly! -package promauto - -import "github.com/prometheus/client_golang/prometheus" - -// NewCounter works like the function of the same name in the prometheus package -// but it automatically registers the Counter with the -// prometheus.DefaultRegisterer. If the registration fails, NewCounter panics. -func NewCounter(opts prometheus.CounterOpts) prometheus.Counter { - return With(prometheus.DefaultRegisterer).NewCounter(opts) -} - -// NewCounterVec works like the function of the same name in the prometheus -// package but it automatically registers the CounterVec with the -// prometheus.DefaultRegisterer. If the registration fails, NewCounterVec -// panics. -func NewCounterVec(opts prometheus.CounterOpts, labelNames []string) *prometheus.CounterVec { - return With(prometheus.DefaultRegisterer).NewCounterVec(opts, labelNames) -} - -// NewCounterFunc works like the function of the same name in the prometheus -// package but it automatically registers the CounterFunc with the -// prometheus.DefaultRegisterer. If the registration fails, NewCounterFunc -// panics. -func NewCounterFunc(opts prometheus.CounterOpts, function func() float64) prometheus.CounterFunc { - return With(prometheus.DefaultRegisterer).NewCounterFunc(opts, function) -} - -// NewGauge works like the function of the same name in the prometheus package -// but it automatically registers the Gauge with the -// prometheus.DefaultRegisterer. If the registration fails, NewGauge panics. -func NewGauge(opts prometheus.GaugeOpts) prometheus.Gauge { - return With(prometheus.DefaultRegisterer).NewGauge(opts) -} - -// NewGaugeVec works like the function of the same name in the prometheus -// package but it automatically registers the GaugeVec with the -// prometheus.DefaultRegisterer. If the registration fails, NewGaugeVec panics. -func NewGaugeVec(opts prometheus.GaugeOpts, labelNames []string) *prometheus.GaugeVec { - return With(prometheus.DefaultRegisterer).NewGaugeVec(opts, labelNames) -} - -// NewGaugeFunc works like the function of the same name in the prometheus -// package but it automatically registers the GaugeFunc with the -// prometheus.DefaultRegisterer. If the registration fails, NewGaugeFunc panics. -func NewGaugeFunc(opts prometheus.GaugeOpts, function func() float64) prometheus.GaugeFunc { - return With(prometheus.DefaultRegisterer).NewGaugeFunc(opts, function) -} - -// NewSummary works like the function of the same name in the prometheus package -// but it automatically registers the Summary with the -// prometheus.DefaultRegisterer. If the registration fails, NewSummary panics. -func NewSummary(opts prometheus.SummaryOpts) prometheus.Summary { - return With(prometheus.DefaultRegisterer).NewSummary(opts) -} - -// NewSummaryVec works like the function of the same name in the prometheus -// package but it automatically registers the SummaryVec with the -// prometheus.DefaultRegisterer. If the registration fails, NewSummaryVec -// panics. -func NewSummaryVec(opts prometheus.SummaryOpts, labelNames []string) *prometheus.SummaryVec { - return With(prometheus.DefaultRegisterer).NewSummaryVec(opts, labelNames) -} - -// NewHistogram works like the function of the same name in the prometheus -// package but it automatically registers the Histogram with the -// prometheus.DefaultRegisterer. If the registration fails, NewHistogram panics. -func NewHistogram(opts prometheus.HistogramOpts) prometheus.Histogram { - return With(prometheus.DefaultRegisterer).NewHistogram(opts) -} - -// NewHistogramVec works like the function of the same name in the prometheus -// package but it automatically registers the HistogramVec with the -// prometheus.DefaultRegisterer. If the registration fails, NewHistogramVec -// panics. -func NewHistogramVec(opts prometheus.HistogramOpts, labelNames []string) *prometheus.HistogramVec { - return With(prometheus.DefaultRegisterer).NewHistogramVec(opts, labelNames) -} - -// NewUntypedFunc works like the function of the same name in the prometheus -// package but it automatically registers the UntypedFunc with the -// prometheus.DefaultRegisterer. If the registration fails, NewUntypedFunc -// panics. -func NewUntypedFunc(opts prometheus.UntypedOpts, function func() float64) prometheus.UntypedFunc { - return With(prometheus.DefaultRegisterer).NewUntypedFunc(opts, function) -} - -// Factory provides factory methods to create Collectors that are automatically -// registered with a Registerer. Create a Factory with the With function, -// providing a Registerer to auto-register created Collectors with. The zero -// value of a Factory creates Collectors that are not registered with any -// Registerer. All methods of the Factory panic if the registration fails. -type Factory struct { - r prometheus.Registerer -} - -// With creates a Factory using the provided Registerer for registration of the -// created Collectors. If the provided Registerer is nil, the returned Factory -// creates Collectors that are not registered with any Registerer. -func With(r prometheus.Registerer) Factory { return Factory{r} } - -// NewCounter works like the function of the same name in the prometheus package -// but it automatically registers the Counter with the Factory's Registerer. -func (f Factory) NewCounter(opts prometheus.CounterOpts) prometheus.Counter { - c := prometheus.NewCounter(opts) - if f.r != nil { - f.r.MustRegister(c) - } - return c -} - -// NewCounterVec works like the function of the same name in the prometheus -// package but it automatically registers the CounterVec with the Factory's -// Registerer. -func (f Factory) NewCounterVec(opts prometheus.CounterOpts, labelNames []string) *prometheus.CounterVec { - c := prometheus.NewCounterVec(opts, labelNames) - if f.r != nil { - f.r.MustRegister(c) - } - return c -} - -// NewCounterFunc works like the function of the same name in the prometheus -// package but it automatically registers the CounterFunc with the Factory's -// Registerer. -func (f Factory) NewCounterFunc(opts prometheus.CounterOpts, function func() float64) prometheus.CounterFunc { - c := prometheus.NewCounterFunc(opts, function) - if f.r != nil { - f.r.MustRegister(c) - } - return c -} - -// NewGauge works like the function of the same name in the prometheus package -// but it automatically registers the Gauge with the Factory's Registerer. -func (f Factory) NewGauge(opts prometheus.GaugeOpts) prometheus.Gauge { - g := prometheus.NewGauge(opts) - if f.r != nil { - f.r.MustRegister(g) - } - return g -} - -// NewGaugeVec works like the function of the same name in the prometheus -// package but it automatically registers the GaugeVec with the Factory's -// Registerer. -func (f Factory) NewGaugeVec(opts prometheus.GaugeOpts, labelNames []string) *prometheus.GaugeVec { - g := prometheus.NewGaugeVec(opts, labelNames) - if f.r != nil { - f.r.MustRegister(g) - } - return g -} - -// NewGaugeFunc works like the function of the same name in the prometheus -// package but it automatically registers the GaugeFunc with the Factory's -// Registerer. -func (f Factory) NewGaugeFunc(opts prometheus.GaugeOpts, function func() float64) prometheus.GaugeFunc { - g := prometheus.NewGaugeFunc(opts, function) - if f.r != nil { - f.r.MustRegister(g) - } - return g -} - -// NewSummary works like the function of the same name in the prometheus package -// but it automatically registers the Summary with the Factory's Registerer. -func (f Factory) NewSummary(opts prometheus.SummaryOpts) prometheus.Summary { - s := prometheus.NewSummary(opts) - if f.r != nil { - f.r.MustRegister(s) - } - return s -} - -// NewSummaryVec works like the function of the same name in the prometheus -// package but it automatically registers the SummaryVec with the Factory's -// Registerer. -func (f Factory) NewSummaryVec(opts prometheus.SummaryOpts, labelNames []string) *prometheus.SummaryVec { - s := prometheus.NewSummaryVec(opts, labelNames) - if f.r != nil { - f.r.MustRegister(s) - } - return s -} - -// NewHistogram works like the function of the same name in the prometheus -// package but it automatically registers the Histogram with the Factory's -// Registerer. -func (f Factory) NewHistogram(opts prometheus.HistogramOpts) prometheus.Histogram { - h := prometheus.NewHistogram(opts) - if f.r != nil { - f.r.MustRegister(h) - } - return h -} - -// NewHistogramVec works like the function of the same name in the prometheus -// package but it automatically registers the HistogramVec with the Factory's -// Registerer. -func (f Factory) NewHistogramVec(opts prometheus.HistogramOpts, labelNames []string) *prometheus.HistogramVec { - h := prometheus.NewHistogramVec(opts, labelNames) - if f.r != nil { - f.r.MustRegister(h) - } - return h -} - -// NewUntypedFunc works like the function of the same name in the prometheus -// package but it automatically registers the UntypedFunc with the Factory's -// Registerer. -func (f Factory) NewUntypedFunc(opts prometheus.UntypedOpts, function func() float64) prometheus.UntypedFunc { - u := prometheus.NewUntypedFunc(opts, function) - if f.r != nil { - f.r.MustRegister(u) - } - return u -} diff --git a/vendor/modules.txt b/vendor/modules.txt index 68e5e2d76..9c1c23086 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -350,7 +350,6 @@ github.com/pmezard/go-difflib/difflib github.com/prometheus/client_golang/prometheus github.com/prometheus/client_golang/prometheus/collectors github.com/prometheus/client_golang/prometheus/internal -github.com/prometheus/client_golang/prometheus/promauto github.com/prometheus/client_golang/prometheus/promhttp github.com/prometheus/client_golang/prometheus/testutil github.com/prometheus/client_golang/prometheus/testutil/promlint