You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@yunikorn.apache.org by pb...@apache.org on 2023/12/07 11:04:37 UTC
(yunikorn-core) branch master updated: [YUNIKORN-2210] Metrics: use WithLabelValues instead of With (#742)
This is an automated email from the ASF dual-hosted git repository.
pbacsko pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/yunikorn-core.git
The following commit(s) were added to refs/heads/master by this push:
new c4c176fe [YUNIKORN-2210] Metrics: use WithLabelValues instead of With (#742)
c4c176fe is described below
commit c4c176fe7f549cae06f1526d5e160ad0c5070f8c
Author: Peter Bacsko <pb...@cloudera.com>
AuthorDate: Thu Dec 7 12:04:24 2023 +0100
[YUNIKORN-2210] Metrics: use WithLabelValues instead of With (#742)
Closes: #742
Signed-off-by: Peter Bacsko <pb...@cloudera.com>
---
pkg/metrics/queue.go | 67 +++++++++++++++++++++++++---------------
pkg/metrics/runtime.go | 8 ++---
pkg/metrics/scheduler.go | 80 ++++++++++++++++++++++++++++--------------------
3 files changed, 92 insertions(+), 63 deletions(-)
diff --git a/pkg/metrics/queue.go b/pkg/metrics/queue.go
index d8127b2f..c7610e95 100644
--- a/pkg/metrics/queue.go
+++ b/pkg/metrics/queue.go
@@ -26,6 +26,23 @@ import (
"github.com/apache/yunikorn-core/pkg/log"
)
+const (
+ AppAccepted = "accepted"
+ AppRunning = "running"
+ AppFailed = "failed"
+ AppRejected = "rejected"
+ AppCompleted = "completed"
+
+ ContainerReleased = "released"
+ ContainerAllocated = "allocated"
+ ContainerRejected = "rejected"
+
+ QueueGuaranteed = "guaranteed"
+ QueueMax = "max"
+ QueuePending = "pending"
+ QueuePreempting = "preempting"
+)
+
// QueueMetrics to declare queue metrics
type QueueMetrics struct {
appMetricsLabel *prometheus.GaugeVec
@@ -105,18 +122,18 @@ func InitQueueMetrics(name string) *QueueMetrics {
}
func (m *QueueMetrics) incQueueApplications(state string) {
- m.appMetricsLabel.With(prometheus.Labels{"state": state}).Inc()
- m.appMetricsSubsystem.With(prometheus.Labels{"state": state}).Inc()
+ m.appMetricsLabel.WithLabelValues(state).Inc()
+ m.appMetricsSubsystem.WithLabelValues(state).Inc()
}
func (m *QueueMetrics) decQueueApplications(state string) {
- m.appMetricsLabel.With(prometheus.Labels{"state": state}).Dec()
- m.appMetricsSubsystem.With(prometheus.Labels{"state": state}).Dec()
+ m.appMetricsLabel.WithLabelValues(state).Dec()
+ m.appMetricsSubsystem.WithLabelValues(state).Dec()
}
func (m *QueueMetrics) setQueueResource(state string, resourceName string, value float64) {
- m.resourceMetricsLabel.With(prometheus.Labels{"state": state, "resource": resourceName}).Set(value)
- m.resourceMetricsSubsystem.With(prometheus.Labels{"state": state, "resource": resourceName}).Set(value)
+ m.resourceMetricsLabel.WithLabelValues(state, resourceName).Set(value)
+ m.resourceMetricsSubsystem.WithLabelValues(state, resourceName).Set(value)
}
func (m *QueueMetrics) Reset() {
@@ -127,16 +144,16 @@ func (m *QueueMetrics) Reset() {
}
func (m *QueueMetrics) IncQueueApplicationsRunning() {
- m.incQueueApplications("running")
+ m.incQueueApplications(AppRunning)
}
func (m *QueueMetrics) DecQueueApplicationsRunning() {
- m.decQueueApplications("running")
+ m.decQueueApplications(AppRunning)
}
func (m *QueueMetrics) GetQueueApplicationsRunning() (int, error) {
metricDto := &dto.Metric{}
- err := m.appMetricsLabel.With(prometheus.Labels{"state": "running"}).Write(metricDto)
+ err := m.appMetricsLabel.WithLabelValues(AppRunning).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -144,12 +161,12 @@ func (m *QueueMetrics) GetQueueApplicationsRunning() (int, error) {
}
func (m *QueueMetrics) IncQueueApplicationsAccepted() {
- m.incQueueApplications("accepted")
+ m.incQueueApplications(AppAccepted)
}
func (m *QueueMetrics) GetQueueApplicationsAccepted() (int, error) {
metricDto := &dto.Metric{}
- err := m.appMetricsLabel.With(prometheus.Labels{"state": "accepted"}).Write(metricDto)
+ err := m.appMetricsLabel.WithLabelValues(AppAccepted).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -157,12 +174,12 @@ func (m *QueueMetrics) GetQueueApplicationsAccepted() (int, error) {
}
func (m *QueueMetrics) IncQueueApplicationsRejected() {
- m.incQueueApplications("rejected")
+ m.incQueueApplications(AppRejected)
}
func (m *QueueMetrics) GetQueueApplicationsRejected() (int, error) {
metricDto := &dto.Metric{}
- err := m.appMetricsLabel.With(prometheus.Labels{"state": "rejected"}).Write(metricDto)
+ err := m.appMetricsLabel.WithLabelValues(AppRejected).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -170,12 +187,12 @@ func (m *QueueMetrics) GetQueueApplicationsRejected() (int, error) {
}
func (m *QueueMetrics) IncQueueApplicationsFailed() {
- m.incQueueApplications("failed")
+ m.incQueueApplications(AppFailed)
}
func (m *QueueMetrics) GetQueueApplicationsFailed() (int, error) {
metricDto := &dto.Metric{}
- err := m.appMetricsLabel.With(prometheus.Labels{"state": "failed"}).Write(metricDto)
+ err := m.appMetricsLabel.WithLabelValues(AppFailed).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -183,12 +200,12 @@ func (m *QueueMetrics) GetQueueApplicationsFailed() (int, error) {
}
func (m *QueueMetrics) IncQueueApplicationsCompleted() {
- m.incQueueApplications("completed")
+ m.incQueueApplications(AppCompleted)
}
func (m *QueueMetrics) GetQueueApplicationsCompleted() (int, error) {
metricDto := &dto.Metric{}
- err := m.appMetricsLabel.With(prometheus.Labels{"state": "completed"}).Write(metricDto)
+ err := m.appMetricsLabel.WithLabelValues(AppCompleted).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -196,33 +213,33 @@ func (m *QueueMetrics) GetQueueApplicationsCompleted() (int, error) {
}
func (m *QueueMetrics) IncAllocatedContainer() {
- m.containerMetrics.With(prometheus.Labels{"state": "allocated"}).Inc()
+ m.containerMetrics.WithLabelValues(ContainerAllocated).Inc()
}
func (m *QueueMetrics) IncReleasedContainer() {
- m.containerMetrics.With(prometheus.Labels{"state": "released"}).Inc()
+ m.containerMetrics.WithLabelValues(ContainerReleased).Inc()
}
func (m *QueueMetrics) AddReleasedContainers(value int) {
- m.containerMetrics.With(prometheus.Labels{"state": "released"}).Add(float64(value))
+ m.containerMetrics.WithLabelValues(ContainerReleased).Add(float64(value))
}
func (m *QueueMetrics) SetQueueGuaranteedResourceMetrics(resourceName string, value float64) {
- m.setQueueResource("guaranteed", resourceName, value)
+ m.setQueueResource(QueueGuaranteed, resourceName, value)
}
func (m *QueueMetrics) SetQueueMaxResourceMetrics(resourceName string, value float64) {
- m.setQueueResource("max", resourceName, value)
+ m.setQueueResource(QueueMax, resourceName, value)
}
func (m *QueueMetrics) SetQueueAllocatedResourceMetrics(resourceName string, value float64) {
- m.setQueueResource("allocated", resourceName, value)
+ m.setQueueResource(ContainerAllocated, resourceName, value)
}
func (m *QueueMetrics) SetQueuePendingResourceMetrics(resourceName string, value float64) {
- m.setQueueResource("pending", resourceName, value)
+ m.setQueueResource(QueuePending, resourceName, value)
}
func (m *QueueMetrics) SetQueuePreemptingResourceMetrics(resourceName string, value float64) {
- m.setQueueResource("preempting", resourceName, value)
+ m.setQueueResource(QueuePreempting, resourceName, value)
}
diff --git a/pkg/metrics/runtime.go b/pkg/metrics/runtime.go
index 725cac73..bd696ebf 100644
--- a/pkg/metrics/runtime.go
+++ b/pkg/metrics/runtime.go
@@ -100,11 +100,11 @@ func (ms *MStatsMetrics) Collect() {
ms.gauge("GCCPUFraction").Set(memStats.GCCPUFraction)
for i, v := range memStats.PauseNs {
- ms.pauseNsTimes.With(prometheus.Labels{PauseNsLabel: strconv.Itoa(i)}).Set(float64(v))
+ ms.pauseNsTimes.WithLabelValues(strconv.Itoa(i)).Set(float64(v))
}
for i, v := range memStats.PauseEnd {
- ms.pauseEndTimes.With(prometheus.Labels{PauseEndLabel: strconv.Itoa(i)}).Set(float64(v))
+ ms.pauseEndTimes.WithLabelValues(strconv.Itoa(i)).Set(float64(v))
}
for _, v := range memStats.BySize {
@@ -115,7 +115,7 @@ func (ms *MStatsMetrics) Collect() {
}
func (ms *MStatsMetrics) gauge(name string) prometheus.Gauge {
- return ms.mstats.With(prometheus.Labels{MemStatsLabel: name})
+ return ms.mstats.WithLabelValues(name)
}
func (ms *MStatsMetrics) Reset() {
@@ -162,7 +162,7 @@ func (gm *GenericMetrics) Reset() {
func (gm *GenericMetrics) gauge(name string) prometheus.Gauge {
formattedName := formatMetricName(name)
- return gm.genericMetrics.With(prometheus.Labels{GenericLabel: formattedName})
+ return gm.genericMetrics.WithLabelValues(formattedName)
}
func initRuntimeMetrics() *RuntimeMetrics {
diff --git a/pkg/metrics/scheduler.go b/pkg/metrics/scheduler.go
index 1a0e5e4b..ad31c755 100644
--- a/pkg/metrics/scheduler.go
+++ b/pkg/metrics/scheduler.go
@@ -30,6 +30,18 @@ import (
"github.com/apache/yunikorn-core/pkg/log"
)
+const (
+ SchedulingError = "error"
+
+ SortingApp = "app"
+ SortingQueue = "queue"
+
+ NodeActive = "active"
+ NodeDraining = "draining"
+ NodeDecommissioned = "decommissioned"
+ NodeUnhealthy = "unhealthy"
+)
+
var resourceUsageRangeBuckets = []string{
"[0,10%]",
"(10%, 20%]",
@@ -172,11 +184,11 @@ func (m *SchedulerMetrics) ObserveSchedulingLatency(start time.Time) {
}
func (m *SchedulerMetrics) ObserveAppSortingLatency(start time.Time) {
- m.sortingLatency.With(prometheus.Labels{"level": "app"}).Observe(SinceInSeconds(start))
+ m.sortingLatency.WithLabelValues(SortingApp).Observe(SinceInSeconds(start))
}
func (m *SchedulerMetrics) ObserveQueueSortingLatency(start time.Time) {
- m.sortingLatency.With(prometheus.Labels{"level": "queue"}).Observe(SinceInSeconds(start))
+ m.sortingLatency.WithLabelValues(SortingQueue).Observe(SinceInSeconds(start))
}
func (m *SchedulerMetrics) ObserveTryNodeLatency(start time.Time) {
@@ -188,12 +200,12 @@ func (m *SchedulerMetrics) ObserveTryPreemptionLatency(start time.Time) {
}
func (m *SchedulerMetrics) AddAllocatedContainers(value int) {
- m.containerAllocation.With(prometheus.Labels{"state": "allocated"}).Add(float64(value))
+ m.containerAllocation.WithLabelValues(ContainerAllocated).Add(float64(value))
}
func (m *SchedulerMetrics) getAllocatedContainers() (int, error) {
metricDto := &dto.Metric{}
- err := m.containerAllocation.With(prometheus.Labels{"state": "allocated"}).Write(metricDto)
+ err := m.containerAllocation.WithLabelValues(ContainerAllocated).Write(metricDto)
if err == nil {
return int(*metricDto.Counter.Value), nil
}
@@ -201,12 +213,12 @@ func (m *SchedulerMetrics) getAllocatedContainers() (int, error) {
}
func (m *SchedulerMetrics) AddReleasedContainers(value int) {
- m.containerAllocation.With(prometheus.Labels{"state": "released"}).Add(float64(value))
+ m.containerAllocation.WithLabelValues(ContainerReleased).Add(float64(value))
}
func (m *SchedulerMetrics) getReleasedContainers() (int, error) {
metricDto := &dto.Metric{}
- err := m.containerAllocation.With(prometheus.Labels{"state": "released"}).Write(metricDto)
+ err := m.containerAllocation.WithLabelValues(ContainerReleased).Write(metricDto)
if err == nil {
return int(*metricDto.Counter.Value), nil
}
@@ -214,16 +226,16 @@ func (m *SchedulerMetrics) getReleasedContainers() (int, error) {
}
func (m *SchedulerMetrics) AddRejectedContainers(value int) {
- m.containerAllocation.With(prometheus.Labels{"state": "rejected"}).Add(float64(value))
+ m.containerAllocation.WithLabelValues(ContainerRejected).Add(float64(value))
}
func (m *SchedulerMetrics) IncSchedulingError() {
- m.containerAllocation.With(prometheus.Labels{"state": "error"}).Inc()
+ m.containerAllocation.WithLabelValues(SchedulingError).Inc()
}
func (m *SchedulerMetrics) GetSchedulingErrors() (int, error) {
metricDto := &dto.Metric{}
- err := m.containerAllocation.With(prometheus.Labels{"state": "error"}).Write(metricDto)
+ err := m.containerAllocation.WithLabelValues(SchedulingError).Write(metricDto)
if err == nil {
return int(*metricDto.Counter.Value), nil
}
@@ -231,24 +243,24 @@ func (m *SchedulerMetrics) GetSchedulingErrors() (int, error) {
}
func (m *SchedulerMetrics) IncTotalApplicationsAccepted() {
- m.applicationSubmission.With(prometheus.Labels{"result": "accepted"}).Inc()
+ m.applicationSubmission.WithLabelValues(AppAccepted).Inc()
}
func (m *SchedulerMetrics) AddTotalApplicationsAccepted(value int) {
- m.applicationSubmission.With(prometheus.Labels{"result": "accepted"}).Add(float64(value))
+ m.applicationSubmission.WithLabelValues(AppAccepted).Add(float64(value))
}
func (m *SchedulerMetrics) IncTotalApplicationsRejected() {
- m.applicationSubmission.With(prometheus.Labels{"result": "rejected"}).Inc()
+ m.applicationSubmission.WithLabelValues(ContainerRejected).Inc()
}
func (m *SchedulerMetrics) AddTotalApplicationsRejected(value int) {
- m.applicationSubmission.With(prometheus.Labels{"result": "rejected"}).Add(float64(value))
+ m.applicationSubmission.WithLabelValues(ContainerRejected).Add(float64(value))
}
func (m *SchedulerMetrics) GetTotalApplicationsRejected() (int, error) {
metricDto := &dto.Metric{}
- err := m.applicationSubmission.With(prometheus.Labels{"result": "rejected"}).Write(metricDto)
+ err := m.applicationSubmission.WithLabelValues(ContainerRejected).Write(metricDto)
if err == nil {
return int(*metricDto.Counter.Value), nil
}
@@ -256,20 +268,20 @@ func (m *SchedulerMetrics) GetTotalApplicationsRejected() (int, error) {
}
func (m *SchedulerMetrics) IncTotalApplicationsRunning() {
- m.application.With(prometheus.Labels{"state": "running"}).Inc()
+ m.application.WithLabelValues(AppRunning).Inc()
}
func (m *SchedulerMetrics) DecTotalApplicationsRunning() {
- m.application.With(prometheus.Labels{"state": "running"}).Dec()
+ m.application.WithLabelValues(AppRunning).Dec()
}
func (m *SchedulerMetrics) SubTotalApplicationsRunning(value int) {
- m.application.With(prometheus.Labels{"state": "running"}).Sub(float64(value))
+ m.application.WithLabelValues(AppRunning).Sub(float64(value))
}
func (m *SchedulerMetrics) GetTotalApplicationsRunning() (int, error) {
metricDto := &dto.Metric{}
- err := m.application.With(prometheus.Labels{"state": "running"}).Write(metricDto)
+ err := m.application.WithLabelValues(AppRunning).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -277,20 +289,20 @@ func (m *SchedulerMetrics) GetTotalApplicationsRunning() (int, error) {
}
func (m *SchedulerMetrics) IncTotalApplicationsFailed() {
- m.application.With(prometheus.Labels{"state": "failed"}).Inc()
+ m.application.WithLabelValues(AppFailed).Inc()
}
func (m *SchedulerMetrics) IncTotalApplicationsCompleted() {
- m.application.With(prometheus.Labels{"state": "completed"}).Inc()
+ m.application.WithLabelValues(AppCompleted).Inc()
}
func (m *SchedulerMetrics) AddTotalApplicationsCompleted(value int) {
- m.application.With(prometheus.Labels{"state": "completed"}).Add(float64(value))
+ m.application.WithLabelValues(AppCompleted).Add(float64(value))
}
func (m *SchedulerMetrics) GetTotalApplicationsCompleted() (int, error) {
metricDto := &dto.Metric{}
- err := m.application.With(prometheus.Labels{"state": "completed"}).Write(metricDto)
+ err := m.application.WithLabelValues(AppCompleted).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -298,24 +310,24 @@ func (m *SchedulerMetrics) GetTotalApplicationsCompleted() (int, error) {
}
func (m *SchedulerMetrics) IncActiveNodes() {
- m.node.With(prometheus.Labels{"state": "active"}).Inc()
+ m.node.WithLabelValues(NodeActive).Inc()
}
func (m *SchedulerMetrics) DecActiveNodes() {
- m.node.With(prometheus.Labels{"state": "active"}).Dec()
+ m.node.WithLabelValues(NodeActive).Dec()
}
func (m *SchedulerMetrics) IncFailedNodes() {
- m.node.With(prometheus.Labels{"state": "failed"}).Inc()
+ m.node.WithLabelValues(AppFailed).Inc()
}
func (m *SchedulerMetrics) DecFailedNodes() {
- m.node.With(prometheus.Labels{"state": "failed"}).Dec()
+ m.node.WithLabelValues(AppFailed).Dec()
}
func (m *SchedulerMetrics) GetFailedNodes() (int, error) {
metricDto := &dto.Metric{}
- err := m.node.With(prometheus.Labels{"state": "failed"}).Write(metricDto)
+ err := m.node.WithLabelValues(AppFailed).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -342,20 +354,20 @@ func (m *SchedulerMetrics) SetNodeResourceUsage(resourceName string, rangeIdx in
}
m.nodeResourceUsage[resourceName] = resourceMetrics
}
- resourceMetrics.With(prometheus.Labels{"range": resourceUsageRangeBuckets[rangeIdx]}).Set(value)
+ resourceMetrics.WithLabelValues(resourceUsageRangeBuckets[rangeIdx]).Set(value)
}
func (m *SchedulerMetrics) IncDrainingNodes() {
- m.node.With(prometheus.Labels{"state": "draining"}).Inc()
+ m.node.WithLabelValues(NodeDraining).Inc()
}
func (m *SchedulerMetrics) DecDrainingNodes() {
- m.node.With(prometheus.Labels{"state": "draining"}).Dec()
+ m.node.WithLabelValues(NodeDraining).Dec()
}
func (m *SchedulerMetrics) GetDrainingNodes() (int, error) {
metricDto := &dto.Metric{}
- err := m.node.With(prometheus.Labels{"state": "draining"}).Write(metricDto)
+ err := m.node.WithLabelValues(NodeDraining).Write(metricDto)
if err == nil {
return int(*metricDto.Gauge.Value), nil
}
@@ -363,13 +375,13 @@ func (m *SchedulerMetrics) GetDrainingNodes() (int, error) {
}
func (m *SchedulerMetrics) IncTotalDecommissionedNodes() {
- m.node.With(prometheus.Labels{"state": "decommissioned"}).Inc()
+ m.node.WithLabelValues(NodeDecommissioned).Inc()
}
func (m *SchedulerMetrics) IncUnhealthyNodes() {
- m.node.With(prometheus.Labels{"state": "unhealthy"}).Inc()
+ m.node.WithLabelValues(NodeUnhealthy).Inc()
}
func (m *SchedulerMetrics) DecUnhealthyNodes() {
- m.node.With(prometheus.Labels{"state": "unhealthy"}).Dec()
+ m.node.WithLabelValues(NodeUnhealthy).Dec()
}
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscribe@yunikorn.apache.org
For additional commands, e-mail: issues-help@yunikorn.apache.org