kubernetes/pkg/controller/volume/persistentvolume/metrics/metrics.go

const pvControllerSubsystem

const totalPVKey

const boundPVKey

const unboundPVKey

const boundPVCKey

const unboundPVCKey

const namespaceLabel

const storageClassLabel

const volumeAttributesClassLabel

const pluginNameLabel

const volumeModeLabel

const pluginNameNotAvailable

var registerMetrics

type PVLister

type PVCLister

// Register all metrics for pv controller.
func Register(pvLister PVLister, pvcLister PVCLister, pluginMgr *volume.VolumePluginMgr) {}

func newPVAndPVCCountCollector(pvLister PVLister, pvcLister PVCLister, pluginMgr *volume.VolumePluginMgr) *pvAndPVCCountCollector {}

type pvAndPVCCountCollector

type pvcBindingMetricDimensions

func getPVCMetricDimensions(pvc *v1.PersistentVolumeClaim) pvcBindingMetricDimensions {}

var _

var totalPVCountDesc

var boundPVCountDesc

var unboundPVCountDesc

var boundPVCCountDesc

var unboundPVCCountDesc

var volumeOperationErrorsMetric

var retroactiveStorageClassMetric

var retroactiveStorageClassErrorMetric

type volumeCount

func (v volumeCount) add(pluginName string, volumeMode string) {}

func (collector *pvAndPVCCountCollector) DescribeWithStability(ch chan<- *metrics.Desc) {}

func (collector *pvAndPVCCountCollector) CollectWithStability(ch chan<- metrics.Metric) {}

func (collector *pvAndPVCCountCollector) getPVPluginName(pv *v1.PersistentVolume) string {}

func (collector *pvAndPVCCountCollector) pvCollect(ch chan<- metrics.Metric) {}

func (collector *pvAndPVCCountCollector) pvcCollect(ch chan<- metrics.Metric) {}

// RecordRetroactiveStorageClassMetric increments only retroactive_storageclass_total
// metric or both retroactive_storageclass_total and retroactive_storageclass_errors_total
// if success is false.
func RecordRetroactiveStorageClassMetric(success bool) {}

// RecordVolumeOperationErrorMetric records error count into metric
// volume_operation_total_errors for provisioning/deletion operations
func RecordVolumeOperationErrorMetric(pluginName, opName string) {}

type operationTimestamp

func newOperationTimestamp(pluginName, operationName string) *operationTimestamp {}

type OperationStartTimeCache

// NewOperationStartTimeCache creates a operation timestamp cache
func NewOperationStartTimeCache() OperationStartTimeCache {}

// AddIfNotExist returns directly if there exists an entry with the key. Otherwise, it
// creates a new operation timestamp using operationName, pluginName, and current timestamp
// and stores the operation timestamp with the key
func (c *OperationStartTimeCache) AddIfNotExist(key, pluginName, operationName string) {}

// Delete deletes a value for a key.
func (c *OperationStartTimeCache) Delete(key string) {}

// Has returns a bool value indicates the existence of a key in the cache
func (c *OperationStartTimeCache) Has(key string) bool {}

// RecordMetric records either an error count metric or a latency metric if there
// exists a start timestamp entry in the cache. For a successful operation, i.e.,
// err == nil, the corresponding timestamp entry will be removed from cache
func RecordMetric(key string, c *OperationStartTimeCache, err error) {}