fix promlinter and boilerplate issues

Signed-off-by: Jing Liu <[email protected]>

Author: 7ing

.DS_Store

@@ -400,7 +400,7 @@ func (m *Manager) issue(ctx context.Context, volumeID string) error {
 	log.Info("Processing issuance")
 
 	// Increase issue count
-	m.metrics.IncrementIssueCallCount(m.nodeNameHash, volumeID)
+	m.metrics.IncrementIssueCallCountTotal(m.nodeNameHash, volumeID)
 
 	if err := m.cleanupStaleRequests(ctx, log, volumeID); err != nil {
 		return fmt.Errorf("cleaning up stale requests: %w", err)
@@ -779,7 +779,7 @@ func (m *Manager) ManageVolumeImmediate(ctx context.Context, volumeID string) (m
 		// how to proceed depending on the context this method was called within.
 		if err := m.issue(ctx, volumeID); err != nil {
 			// Increase issue error count
-			m.metrics.IncrementIssueErrorCount(m.nodeNameHash, volumeID)
+			m.metrics.IncrementIssueErrorCountTotal(m.nodeNameHash, volumeID)
 			return true, err
 		}
 	}
@@ -808,7 +808,7 @@ func (m *Manager) manageVolumeIfNotManaged(volumeID string) (managed bool) {
 	stopCh := make(chan struct{})
 	m.managedVolumes[volumeID] = stopCh
 	// Increase managed volume count for this driver
-	m.metrics.IncrementManagedVolumeCount(m.nodeNameHash)
+	m.metrics.IncrementManagedVolumeCountTotal(m.nodeNameHash)
 
 	return true
 }
@@ -828,7 +828,7 @@ func (m *Manager) startRenewalRoutine(volumeID string) (started bool) {
 
 	// Increase managed certificate count for this driver.
 	// We assume each volume will have one certificate to be managed.
-	m.metrics.IncrementManagedCertificateCount(m.nodeNameHash)
+	m.metrics.IncrementManagedCertificateCountTotal(m.nodeNameHash)
 
 	// Create a context that will be cancelled when the stopCh is closed
 	ctx, cancel := context.WithCancel(context.Background())
@@ -866,7 +866,7 @@ func (m *Manager) startRenewalRoutine(volumeID string) (started bool) {
 						if err := m.issue(issueCtx, volumeID); err != nil {
 							log.Error(err, "Failed to issue certificate, retrying after applying exponential backoff")
 							// Increase issue error count
-							m.metrics.IncrementIssueErrorCount(m.nodeNameHash, volumeID)
+							m.metrics.IncrementIssueErrorCountTotal(m.nodeNameHash, volumeID)
 							return false, nil
 						}
 						return true, nil

manager/manager.go

@@ -38,10 +38,10 @@ type Metrics struct {
 	certificateRequestExpiryTimeSeconds  *prometheus.GaugeVec
 	certificateRequestRenewalTimeSeconds *prometheus.GaugeVec
 	certificateRequestReadyStatus        *prometheus.GaugeVec
-	driverIssueCallCount                 *prometheus.CounterVec
-	driverIssueErrorCount                *prometheus.CounterVec
-	managedVolumeCount                   *prometheus.CounterVec
-	managedCertificateCount              *prometheus.CounterVec
+	driverIssueCallCountTotal            *prometheus.CounterVec
+	driverIssueErrorCountTotal           *prometheus.CounterVec
+	managedVolumeCountTotal              *prometheus.CounterVec
+	managedCertificateCountTotal         *prometheus.CounterVec
 }
 
 // New creates a Metrics struct and populates it with prometheus metric types.
@@ -77,41 +77,41 @@ func New(logger *logr.Logger, registry *prometheus.Registry) *Metrics {
 			[]string{"name", "namespace", "condition", "issuer_name", "issuer_kind", "issuer_group"},
 		)
 
-		driverIssueCallCount = prometheus.NewCounterVec(
+		driverIssueCallCountTotal = prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace: namespace,
 				Subsystem: subsystem,
-				Name:      "driver_issue_call_count",
+				Name:      "driver_issue_call_count_total",
 				Help:      "The number of issue() calls made by the driver.",
 			},
 			[]string{"node", "volume"},
 		)
 
-		driverIssueErrorCount = prometheus.NewCounterVec(
+		driverIssueErrorCountTotal = prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace: namespace,
 				Subsystem: subsystem,
-				Name:      "driver_issue_error_count",
+				Name:      "driver_issue_error_count_total",
 				Help:      "The number of errors encountered during the driver issue() calls.",
 			},
 			[]string{"node", "volume"},
 		)
 
-		managedVolumeCount = prometheus.NewCounterVec(
+		managedVolumeCountTotal = prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace: namespace,
 				Subsystem: subsystem,
-				Name:      "managed_volume_count",
+				Name:      "managed_volume_count_total",
 				Help:      "The number of volume managed by the csi driver.",
 			},
 			[]string{"node"},
 		)
 
-		managedCertificateCount = prometheus.NewCounterVec(
+		managedCertificateCountTotal = prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace: namespace,
 				Subsystem: subsystem,
-				Name:      "managed_certificate_count",
+				Name:      "managed_certificate_count_total",
 				Help:      "The number of certificates managed by the csi driver.",
 			},
 			[]string{"node"},
@@ -126,19 +126,19 @@ func New(logger *logr.Logger, registry *prometheus.Registry) *Metrics {
 		certificateRequestExpiryTimeSeconds:  certificateRequestExpiryTimeSeconds,
 		certificateRequestRenewalTimeSeconds: certificateRequestRenewalTimeSeconds,
 		certificateRequestReadyStatus:        certificateRequestReadyStatus,
-		driverIssueCallCount:                 driverIssueCallCount,
-		driverIssueErrorCount:                driverIssueErrorCount,
-		managedVolumeCount:                   managedVolumeCount,
-		managedCertificateCount:              managedCertificateCount,
+		driverIssueCallCountTotal:            driverIssueCallCountTotal,
+		driverIssueErrorCountTotal:           driverIssueErrorCountTotal,
+		managedVolumeCountTotal:              managedVolumeCountTotal,
+		managedCertificateCountTotal:         managedCertificateCountTotal,
 	}
 
 	m.registry.MustRegister(m.certificateRequestExpiryTimeSeconds)
 	m.registry.MustRegister(m.certificateRequestRenewalTimeSeconds)
 	m.registry.MustRegister(m.certificateRequestReadyStatus)
-	m.registry.MustRegister(m.driverIssueCallCount)
-	m.registry.MustRegister(m.driverIssueErrorCount)
-	m.registry.MustRegister(m.managedVolumeCount)
-	m.registry.MustRegister(m.managedCertificateCount)
+	m.registry.MustRegister(m.driverIssueCallCountTotal)
+	m.registry.MustRegister(m.driverIssueErrorCountTotal)
+	m.registry.MustRegister(m.managedVolumeCountTotal)
+	m.registry.MustRegister(m.managedCertificateCountTotal)
 
 	return m
 }
@@ -151,22 +151,22 @@ func (m *Metrics) DefaultHandler() http.Handler {
 	return mux
 }
 
-// IncrementIssueCallCount will increase the issue call counter for the driver.
-func (m *Metrics) IncrementIssueCallCount(nodeNameHash, volumeID string) {
-	m.driverIssueCallCount.WithLabelValues(nodeNameHash, volumeID).Inc()
+// IncrementIssueCallCountTotal will increase the issue call counter for the driver.
+func (m *Metrics) IncrementIssueCallCountTotal(nodeNameHash, volumeID string) {
+	m.driverIssueCallCountTotal.WithLabelValues(nodeNameHash, volumeID).Inc()
 }
 
-// IncrementIssueErrorCount will increase count of errors during issue call of the driver.
-func (m *Metrics) IncrementIssueErrorCount(nodeNameHash, volumeID string) {
-	m.driverIssueErrorCount.WithLabelValues(nodeNameHash, volumeID).Inc()
+// IncrementIssueErrorCountTotal will increase count of errors during issue call of the driver.
+func (m *Metrics) IncrementIssueErrorCountTotal(nodeNameHash, volumeID string) {
+	m.driverIssueErrorCountTotal.WithLabelValues(nodeNameHash, volumeID).Inc()
 }
 
-// IncrementManagedVolumeCount will increase the managed volume counter for the driver.
-func (m *Metrics) IncrementManagedVolumeCount(nodeNameHash string) {
-	m.managedVolumeCount.WithLabelValues(nodeNameHash).Inc()
+// IncrementManagedVolumeCountTotal will increase the managed volume counter for the driver.
+func (m *Metrics) IncrementManagedVolumeCountTotal(nodeNameHash string) {
+	m.managedVolumeCountTotal.WithLabelValues(nodeNameHash).Inc()
 }
 
-// IncrementManagedCertificateCount will increase the managed certificate count for the driver.
-func (m *Metrics) IncrementManagedCertificateCount(nodeNameHash string) {
-	m.managedCertificateCount.WithLabelValues(nodeNameHash).Inc()
+// IncrementManagedCertificateCountTotal will increase the managed certificate count for the driver.
+func (m *Metrics) IncrementManagedCertificateCountTotal(nodeNameHash string) {
+	m.managedCertificateCountTotal.WithLabelValues(nodeNameHash).Inc()
 }

metrics/metrics.go

@@ -1,3 +1,19 @@
+/*
+Copyright 2025 The cert-manager 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 integration
 
 import (
@@ -207,15 +223,15 @@ certmanager_csi_certificate_request_ready_status{condition="Unknown",issuer_grou
 # HELP certmanager_csi_certificate_request_renewal_timestamp_seconds The number of seconds before expiration time the certificate request should renew.
 # TYPE certmanager_csi_certificate_request_renewal_timestamp_seconds gauge
 certmanager_csi_certificate_request_renewal_timestamp_seconds{issuer_group="test-issuer-group",issuer_kind="test-issuer-kind",issuer_name="test-issuer",name="test-cr-name",namespace="test-ns"} 200
-# HELP certmanager_csi_driver_issue_call_count The number of issue() calls made by the driver.
-# TYPE certmanager_csi_driver_issue_call_count counter
-certmanager_csi_driver_issue_call_count{node="f56fd9f8b",volume="test-vol"} 1
-# HELP certmanager_csi_managed_certificate_count The number of certificates managed by the csi driver.
-# TYPE certmanager_csi_managed_certificate_count counter
-certmanager_csi_managed_certificate_count{node="f56fd9f8b"} 1
-# HELP certmanager_csi_managed_volume_count The number of volume managed by the csi driver.
-# TYPE certmanager_csi_managed_volume_count counter
-certmanager_csi_managed_volume_count{node="f56fd9f8b"} 1
+# HELP certmanager_csi_driver_issue_call_count_total The number of issue() calls made by the driver.
+# TYPE certmanager_csi_driver_issue_call_count_total counter
+certmanager_csi_driver_issue_call_count_total{node="f56fd9f8b",volume="test-vol"} 1
+# HELP certmanager_csi_managed_certificate_count_total The number of certificates managed by the csi driver.
+# TYPE certmanager_csi_managed_certificate_count_total counter
+certmanager_csi_managed_certificate_count_total{node="f56fd9f8b"} 1
+# HELP certmanager_csi_managed_volume_count_total The number of volume managed by the csi driver.
+# TYPE certmanager_csi_managed_volume_count_total counter
+certmanager_csi_managed_volume_count_total{node="f56fd9f8b"} 1
 `
 	waitForMetrics(t, ctx, metricsEndpoint, strings.ReplaceAll(expectedOutputTemplate, "test-cr-name", req.Name))
 
@@ -229,15 +245,15 @@ certmanager_csi_managed_volume_count{node="f56fd9f8b"} 1
 	}
 
 	// Should expose no CertificateRequest and only metrics counters
-	waitForMetrics(t, ctx, metricsEndpoint, `# HELP certmanager_csi_driver_issue_call_count The number of issue() calls made by the driver.
-# TYPE certmanager_csi_driver_issue_call_count counter
-certmanager_csi_driver_issue_call_count{node="f56fd9f8b",volume="test-vol"} 1
-# HELP certmanager_csi_managed_certificate_count The number of certificates managed by the csi driver.
-# TYPE certmanager_csi_managed_certificate_count counter
-certmanager_csi_managed_certificate_count{node="f56fd9f8b"} 1
-# HELP certmanager_csi_managed_volume_count The number of volume managed by the csi driver.
-# TYPE certmanager_csi_managed_volume_count counter
-certmanager_csi_managed_volume_count{node="f56fd9f8b"} 1
+	waitForMetrics(t, ctx, metricsEndpoint, `# HELP certmanager_csi_driver_issue_call_count_total The number of issue() calls made by the driver.
+# TYPE certmanager_csi_driver_issue_call_count_total counter
+certmanager_csi_driver_issue_call_count_total{node="f56fd9f8b",volume="test-vol"} 1
+# HELP certmanager_csi_managed_certificate_count_total The number of certificates managed by the csi driver.
+# TYPE certmanager_csi_managed_certificate_count_total counter
+certmanager_csi_managed_certificate_count_total{node="f56fd9f8b"} 1
+# HELP certmanager_csi_managed_volume_count_total The number of volume managed by the csi driver.
+# TYPE certmanager_csi_managed_volume_count_total counter
+certmanager_csi_managed_volume_count_total{node="f56fd9f8b"} 1
 `)
 
 }